Forem: Roobia

10 Mejores Herramientas de Documentación API REST 2026

Roobia — Wed, 08 Apr 2026 08:47:30 +0000

¡Hola, entusiastas y desarrolladores de tecnología! 👋 ¿Alguna vez se han encontrado perdidos en el laberinto de las APIs? ¿O tal vez están creando una API y quieren asegurarse de que su documentación sea lo más clara posible? Hoy nos sumergiremos en el mundo de las herramientas de documentación de API REST. Ya seas experimentado o principiante, esta guía te mostrará cómo implementar documentación profesional usando las mejores herramientas disponibles.

Prueba Apidog hoy mismo

¡Muy bien, empecemos!

1. Apidog

Su herramienta API todo en uno

Apidog es mucho más que una herramienta de documentación; es una plataforma API todo en uno. Con Apidog puedes diseñar, probar y documentar tus APIs de forma centralizada, lo que facilita el flujo de trabajo y reduce la complejidad técnica.

¿Por qué implementar Apidog?

Funciones completas: Utiliza diseño, pruebas y documentación de API en una sola interfaz.
Fácil de usar: Interfaz intuitiva, ideal para quienes buscan comenzar rápido sin curva de aprendizaje pronunciada.
Gratis: Descarga gratuita y sin restricciones para comenzar de inmediato.

¿Sabías que Apidog es la mejor alternativa a Postman? Instálalo y empieza a documentar tu API en minutos.

2. SwaggerHub

La potencia de la documentación de API

SwaggerHub es estándar para crear, compartir y colaborar en diseños de API usando OpenAPI Specification. Si necesitas documentación interactiva, sigue estos pasos básicos:

Crea tu especificación OpenAPI directamente en SwaggerHub.
Comparte la documentación generada automáticamente con tu equipo o clientes.
Permite probar endpoints directamente desde la interfaz de SwaggerHub.

Ventajas clave

Documentación interactiva: Permite probar endpoints en vivo desde la documentación.
Colaboración: Varios desarrolladores pueden editar y revisar la API en simultáneo.
Integraciones: Se conecta con herramientas como GitHub y Jira.

Ideal para equipos que buscan estandarizar y profesionalizar la documentación de sus APIs.

3. Postman

Más allá de las pruebas: Postman para la documentación

Postman es conocido por las pruebas de API, pero también permite documentar de manera eficiente. Para sacarle provecho:

Crea colecciones de solicitudes en Postman.
Agrega descripciones detalladas y ejemplos de respuestas.
Publica documentación con un clic para compartirla con tu equipo o clientes.

Ventajas clave

Interfaz intuitiva: Documenta y prueba en un solo lugar.
Documentación en vivo: Actualizaciones automáticas cuando cambias las requests.
Comunidad: Recursos y soporte disponibles para resolver cualquier duda.

Perfecto para quienes buscan una herramienta integral para pruebas y documentación.

4. Redoc

Documentación de API limpia y elegante

Redoc destaca por su diseño minimalista orientado a la experiencia del usuario. Para empezar:

Escribe tu especificación OpenAPI en YAML o JSON.
Utiliza Redoc para renderizar la documentación automáticamente.
Personaliza el tema según tu marca mediante configuración sencilla.

Puntos destacados

Personalizable: Cambia colores, logos y fuentes fácilmente.
Soporte de Markdown: Agrega información adicional para mayor claridad.
Diseño responsive: Documentación optimizada para todos los dispositivos.

Ideal para proyectos donde la presentación visual es clave.

5. DapperDox

La elección colaborativa

DapperDox está pensado para equipos que requieren colaboración y control de versiones en la documentación.

Características clave

Edición multiusuario: Trabaja simultáneamente con varios miembros del equipo.
Diagramas integrados: Añade diagramas explicativos para mejorar la comprensión.
Control de versiones: Administra fácilmente distintas versiones de tu API.

Recomendado para equipos grandes y flujos de trabajo colaborativos.

6. Slate

El favorito del desarrollador

Slate es open source y permite generar documentación atractiva a partir de archivos Markdown.

Ventajas clave

Basado en Markdown: Edición sencilla y rápida.
Generador de sitios estáticos: Hospeda la documentación como HTML estático.
Diseño responsive: Tu documentación se adapta a cualquier dispositivo.

Ideal para quienes prefieren flujo de trabajo basado en Markdown y despliegue estático.

7. ReadMe

Documentación de API centrada en el usuario

ReadMe permite crear documentación interactiva enfocada en la experiencia del usuario final.

Características principales

Documentación interactiva: Prueba endpoints desde la misma documentación.
Personalización visual: Ajusta fácilmente la apariencia.
Analíticas: Monitorea cómo los usuarios interactúan con tu documentación.

Perfecto para APIs públicas donde la usabilidad es prioritaria.

8. DocFX

La herramienta de documentación versátil

DocFX es ideal para proyectos que requieren manejar varios tipos de documentación, no solo APIs.

Características

Soporte multilingüe: Documenta tus APIs en varios idiomas.
Plantillas personalizables: Ajusta el diseño según tu marca.
Integración sencilla: Conéctalo con otros servicios y flujos de trabajo.

Recomendado para proyectos complejos con necesidades de documentación mixtas.

9. GitBook

Documentación como código

GitBook es una plataforma moderna que facilita escribir, versionar y colaborar en documentación técnica.

Ventajas clave

Soporte de Markdown: Flujo ágil con sintaxis sencilla.
Control de versiones: Integración con Git para historial de cambios.
Colaboración: Edición simultánea para equipos distribuidos.

Ideal para equipos que gestionan la documentación como parte del ciclo de desarrollo.

10. Stoplight

Documentación de API con enfoque en el diseño

Stoplight facilita el diseño visual de APIs y la generación de documentación estructurada.

Puntos destacados

Editor visual: Diseña y documenta APIs de forma gráfica.
Servidores simulados: Prueba tus endpoints antes del despliegue real.
Colaboración: Todo tu equipo puede participar en tiempo real.

Perfecto para quienes priorizan el diseño y la validación temprana de APIs.

Conclusión

Estas son las 10 mejores herramientas para documentar APIs REST de manera profesional y eficiente. Tanto si trabajas solo como en equipo, elegir la herramienta adecuada optimizará tu flujo de desarrollo y la experiencia de quienes consumen tus APIs. Recuerda: la documentación es clave para el éxito de cualquier API.

💡¿Listo para llevar tu documentación al siguiente nivel? Descarga Apidog gratis hoy mismo y explora todas sus funciones. ¡Haz la prueba y mejora tu flujo de trabajo API!

Mitos de Claude: Anthropic dice que este modelo es demasiado peligroso para lanzarlo

Roobia — Wed, 08 Apr 2026 06:43:14 +0000

En resumen

Claude Mythos Preview parece ser un modelo restringido de Anthropic que se está probando a través del Proyecto Glasswing, un programa de vista previa enfocado en ciberseguridad y no en un lanzamiento público. Los números de referencia reportados sugieren que podría ser mucho más fuerte que Claude Opus 4.6 en tareas de ingeniería de software, pero Anthropic aún no lo ha lanzado ampliamente. La razón probable es el riesgo de doble uso: un modelo que ayuda a los defensores también puede ayudar a los atacantes.

Prueba Apidog hoy

Introducción

Cada laboratorio de IA importante afirma priorizar la seguridad, pero pocos lo demuestran reteniendo un modelo potente en vez de lanzarlo al mercado rápidamente.

Eso es lo que hace interesante a Claude Mythos Preview. Anthropic no lo ha anunciado como un lanzamiento convencional de Claude. No hay una API pública general, ni producto de chat estándar, ni página de "pruébalo ahora" para todos. En cambio, el modelo apareció en informes relacionados con el Proyecto Glasswing, un programa restringido centrado en ciberseguridad defensiva.

Lo relevante no es solo el acceso restringido, sino que los números de referencia publicados para Claude Mythos Preview apuntan a un salto considerable respecto a Claude Opus 4.6 en tareas como SWE-Bench, relacionadas con la codificación. Si se confirman esos datos, Anthropic podría tener un modelo que cambie el equilibrio entre la ciberseguridad ofensiva y defensiva.

💡 Tip: Si construyes herramientas sobre APIs de modelos de IA, aquí es donde importa una estrategia API-first. Los laboratorios pueden exponer un modelo a socios restringidos mucho antes de un lanzamiento público. Apidog permite modelar futuros flujos de API, simular endpoints restringidos y probar integraciones antes de que el acceso se abra. Úsalo para prototipar integraciones de modelos de IA sin depender del lanzamiento público.

¿Qué es Claude Mythos Preview?

Según reportes actuales, Claude Mythos Preview es un modelo de Anthropic no lanzado públicamente y disponible solo para socios e investigadores seleccionados de ciberseguridad defensiva.

Esto no es un lanzamiento estándar como Sonnet u Opus, sino un acceso controlado y restringido a un caso de uso específico. Reuters reporta que Anthropic trabaja con socios como Amazon, Microsoft, Apple, Google, Nvidia, CrowdStrike y Palo Alto Networks en el Proyecto Glasswing, con el foco en investigación de ciberseguridad defensiva, no en consumidores masivos.

En resumen: Claude Mythos Preview es un modelo de Anthropic de acceso restringido para seguridad defensiva, no un nuevo nivel público de Claude.

Por qué el modelo está causando tanta atención

La razón es directa: los números de referencia reportados son excepcionalmente altos.

Según la cobertura reciente, Claude Mythos Preview logró:

Referencia	Claude Mythos Preview	Claude Opus 4.6
SWE-Bench Verificado	93.9%	80.8%
SWE-Bench Pro	77.8%	53.4%

Si estos datos son correctos, el avance es significativo.

SWE-Bench es una referencia pública clara de habilidad en ingeniería de software: evalúa si el modelo puede leer un repo, entender bugs, modificar código correctamente y resolver tareas bajo restricciones realistas. Mejorar tanto sobre Opus 4.6 sugiere un salto importante en capacidades agénticas y de codificación.

Esto implica que Anthropic podría tener un modelo mucho más fuerte que el público y, aun así, decide no lanzarlo ampliamente.

Por qué Anthropic podría estar manteniendo Claude Mythos en privado

La explicación más probable: riesgo de doble uso.

Un modelo capaz de ayudar a defensores a encontrar vulnerabilidades, analizar ataques, revisar código inseguro y automatizar remediaciones puede también facilitar flujos ofensivos. La capacidad que ayuda a un equipo azul a parchear, puede ayudar a un equipo rojo o atacante a moverse más rápido.

Esto se agrava cuando el modelo:

Comprende código a escala de repositorio
Usa herramientas autónomamente
Reproduce vulnerabilidades
Resuelve problemas de largo plazo
Encadena acciones sin perder contexto

Estas son justo las habilidades buscadas para agentes de código, y también las que preocupan en ciberseguridad.

Anthropic ya había sugerido que los modelos frontera requieren estrategias de despliegue más específicas. Claude Mythos Preview es el ejemplo más claro: "Restringe primero, aprende de usuarios verificados y luego decide el siguiente paso", en vez de "lanza y parchea después".

Qué parece significar el Proyecto Glasswing

El Proyecto Glasswing es el marco que contextualiza Mythos.

No es simplemente "un modelo mejor". Es "un modelo mejor, pero solo socios defensivos de confianza pueden usarlo". Esto cambia la narrativa del producto.

No hay un lanzamiento para consumidores; es un programa de vista previa de seguridad. El KPI no es el crecimiento masivo, sino la evaluación controlada: entender qué puede hacer el modelo, qué riesgos aparecen y si las salvaguardas son suficientes.

Esto es un cambio relevante: las compañías de IA han buscado acceso público masivo mientras hablan de seguridad. Glasswing sugiere lo contrario: los sistemas más potentes pueden primero ir a implementaciones sectoriales limitadas bajo pruebas reales.

¿Es Claude Mythos más fuerte que Opus 4.6?

Según los números reportados, podría serlo.

Concretamente:

Los números sugieren que Claude Mythos Preview supera a Opus 4.6 en tareas de SWE-Bench
Anthropic lo trata como modelo de mayor riesgo
No hay implementación pública estándar

Pero no se puede afirmar con certeza:

Que sea más fuerte en todas las categorías
Que las condiciones de comparación fueran idénticas
Que usuarios públicos verían las mismas mejoras

La versión cauta: Claude Mythos Preview parece significativamente más fuerte que Opus 4.6 en benchmarks clave de codificación, y tan capaz que Anthropic restringe el acceso.

Qué podría significar esto para los desarrolladores

Para la mayoría, Claude Mythos no está disponible hoy, pero es relevante porque apunta al futuro de los modelos de codificación.

Tres implicaciones clave:

1. Los modelos públicos de Claude pueden no reflejar el límite de Anthropic

El mejor modelo público de Claude puede estar muy lejos de la mejor capacidad interna. Mythos Preview sugiere que la brecha puede ser mayor de lo que muchos asumían.

2. La capacidad cibernética podría ser el principal cuello de botella para el lanzamiento

La restricción principal ya no es la calidad, sino si el modelo supera el umbral de riesgo de uso indebido ofensivo.

3. Los mejores modelos pueden llegar primero a través de programas empresariales restringidos

En vez de lanzamientos públicos, los sistemas más potentes pueden aparecer primero en redes de socios, pilotos industriales y vistas previas controladas.

Esto impacta cómo los desarrolladores planifican su hoja de ruta, evalúan proveedores y consideran el riesgo de acceso.

Qué podría significar esto para la industria de la IA

Claude Mythos Preview puede ser más relevante como señal que como producto.

Si Anthropic retiene un modelo por riesgo cibernético, otros laboratorios podrían hacer lo mismo. Eso crearía un mercado dual:

Modelos públicos con acceso amplio y restricciones
Modelos restringidos con más capacidades y acceso controlado

Esto afecta la evaluación comparativa: un laboratorio puede tener un sistema mucho más potente que el público, mientras compite con un lanzamiento más seguro y débil. También dificulta juzgar la frontera real solo por las APIs públicas.

Políticamente, este es el caso que legisladores y expertos de seguridad anticipaban: ¿pueden los laboratorios lanzar modelos que ayuden defensivamente sin facilitar el uso ofensivo? Claude Mythos Preview es un ejemplo de un laboratorio enfrentando este dilema en tiempo real.

¿Deberían los desarrolladores preocuparse ahora mismo?

Sí, pero no porque debas cambiar de herramientas hoy.

La preocupación está en cómo interpretar los anuncios:

Cuando un laboratorio dice que su modelo público es el "mejor disponible", puede que no sea su modelo más potente, solo el más potente que están dispuestos a lanzar abiertamente. Eso cambia la perspectiva.

También afecta el posicionamiento competitivo: si Anthropic retiene un modelo de codificación más fuerte, las comparaciones entre Claude, GPT, Gemini, GLM y open weights pueden subestimar el poder real de los sistemas privados.

Conclusión

Claude Mythos Preview no es un producto normal. Es un modelo restringido de Anthropic que puede ser mucho más fuerte que Claude Opus 4.6 en ingeniería de software, y lo bastante delicado como para que Anthropic decida no lanzarlo ampliamente.

Eso lo convierte en una de las historias más relevantes de IA del momento.

Si los benchmarks reportados son precisos, el titular no es solo que Anthropic haya creado un modelo mejor, sino que ya podría estar operando en un entorno donde algunos modelos frontera son demasiado capaces, o demasiado riesgosos, para un lanzamiento inmediato.

Esto marcaría un cambio en cómo los sistemas avanzados de IA llegan al mercado.

Preguntas Frecuentes

¿Qué es Claude Mythos Preview?

Según reportes actuales, es un modelo de vista previa restringido de Anthropic, probado con socios seleccionados de ciberseguridad defensiva, no lanzado públicamente.

¿Está Claude Mythos disponible para el público?

No hay lanzamiento público anunciado. Los reportes indican acceso restringido vía Proyecto Glasswing.

¿Es Claude Mythos más fuerte que Claude Opus 4.6?

Los benchmarks reportados indican que podría ser significativamente más fuerte en tareas de codificación tipo SWE-Bench, aunque no necesariamente en todas las categorías.

¿Qué es el Proyecto Glasswing?

El Proyecto Glasswing es el programa de acceso restringido de Anthropic para evaluar Claude Mythos Preview en entornos de ciberseguridad defensiva.

¿Por qué Anthropic retendría un modelo más fuerte?

Probablemente por riesgo de doble uso: un modelo que ayuda a defensores también puede facilitar el uso ofensivo.

¿Pueden los desarrolladores usar Claude Mythos hoy?

No de forma general. Por ahora, el acceso parece limitado a socios e investigadores seleccionados, no usuarios públicos de API.

Cómo usar GLM-5.1 con Claude Code: Guía completa de configuración

Roobia — Wed, 08 Apr 2026 06:12:12 +0000

TL;DR

Puedes usar GLM-5.1 con Claude Code enrutando Claude Code a través de la API compatible con OpenAI de BigModel. Configura la URL base en https://open.bigmodel.cn/api/paas/v4/, usa el nombre del modelo glm-5.1 y autentícate con tu clave API de BigModel. Una vez configurado, Claude Code puede usar GLM-5.1 para tareas de codificación, exploración de repositorios, refactorización y flujos de trabajo de agente más largos.

Prueba Apidog hoy

Introducción

Claude Code es una de las mejores interfaces para la codificación asistida por IA, pero la interfaz y el modelo son dos cosas separadas. Si tu configuración de Claude Code admite proveedores compatibles con OpenAI, puedes intercambiar el modelo de backend y probar un motor de codificación diferente sin cambiar demasiado tu flujo de trabajo.

Eso hace que GLM-5.1 sea interesante. Z.AI lanzó GLM-5.1 como su modelo estrella para ingeniería de agentes, y los resultados publicados son sólidos: #1 en SWE-Bench Pro, un gran salto sobre GLM-5 en Terminal-Bench 2.0 y un comportamiento mucho mejor a largo plazo en tareas de codificación que se ejecutan durante muchas iteraciones. Si te gusta cómo Claude Code maneja las herramientas, los archivos y la codificación iterativa, vale la pena probar GLM-5.1 detrás de esa misma interfaz.

💡 Si estás comparando backends de modelos para un flujo de trabajo de codificación, Apidog te ayuda con la parte de la API. Puedes documentar el endpoint de BigModel, simular respuestas compatibles con OpenAI y probar cómo tus herramientas internas manejan diferentes proveedores antes de conectarlos a sistemas de producción. Descarga Apidog gratis si quieres comparar APIs de modelos lado a lado.

Esta guía muestra la configuración completa, cómo funciona la ruta de solicitud, qué esperar de GLM-5.1 en Claude Code, problemas comunes y cómo decidir si este cambio vale la pena para tu flujo de trabajo.

¿Por qué usar GLM-5.1 con Claude Code?

Hay tres razones principales:

1. Quieres el flujo de trabajo de Claude Code, pero un modelo diferente

Claude Code es útil por cómo funciona: puede inspeccionar archivos, proponer ediciones, iterar sobre errores y permanecer dentro de un bucle de codificación. Si tu configuración permite proveedores personalizados compatibles con OpenAI, puedes mantener ese flujo de trabajo mientras cambias el modelo subyacente.

2. GLM-5.1 está diseñado para sesiones de codificación largas

GLM-5.1 destaca en mantenerse útil en ejecuciones largas. Z.AI mostró que mejoraba a través de cientos de iteraciones y miles de llamadas a herramientas en tareas de optimización. Eso se adapta bien al uso de estilo Claude Code donde no sólo haces una pregunta, sino ejecutas una sesión de codificación completa.

3. Quieres otra opción de costo/rendimiento

GLM-5.1 puede ser una alternativa práctica para sesiones de mucha codificación. La API de BigModel usa cuota en vez de precios por token, por lo que para algunos equipos puede ser mejor que pagar por sesión directamente a Anthropic u OpenAI.

Para una descripción general completa del modelo y el contexto de los benchmarks, consulta qué es GLM-5.1.

Lo que necesitas antes de la configuración

Asegúrate de tener lo siguiente:

Una cuenta de BigModel en https://bigmodel.cn
Una clave API de BigModel
Claude Code instalado localmente
Una versión o ruta de configuración de Claude Code que admita proveedores personalizados compatibles con OpenAI

El punto clave es el último. GLM-5.1 no se conecta a Claude Code con un SDK especial, sino porque la API de BigModel es compatible con OpenAI.

Los valores exactos que necesitas

Solo necesitas estos tres valores para que el enrutamiento funcione:

URL base

https://open.bigmodel.cn/api/paas/v4/

Nombre del modelo

glm-5.1

Encabezado de autorización

Authorization: Bearer TU_CLAVE_API_DE_BIGMODEL

Eso es todo lo esencial. El resto es dónde colocar estos valores en Claude Code.

Paso 1: crea y almacena tu clave API de BigModel

Abre la consola de desarrolladores de BigModel y genera una clave API.
Guárdala como variable de entorno:

export BIGMODEL_API_KEY="tu_clave_api_aquí"

Si usas zsh, pon esa línea en ~/.zshrc.
Si usas bash, ponla en ~/.bashrc o ~/.bash_profile.

Recarga tu shell:

source ~/.zshrc

Verifica que se cargó:

echo $BIGMODEL_API_KEY

Deberías ver la clave impresa. Si no aparece nada, Claude Code no podrá autenticarse.

Consejo: Usar variables de entorno es más seguro y fácil de rotar.

Paso 2: actualiza la configuración de Claude Code

La configuración suele estar en:

~/.claude/settings.json

Ejemplo mínimo compatible con OpenAI:

{
  "model": "glm-5.1",
  "baseURL": "https://open.bigmodel.cn/api/paas/v4/",
  "apiKey": "tu_clave_api_de_bigmodel"
}

Si tu versión admite variables de entorno:

{
  "model": "glm-5.1",
  "baseURL": "https://open.bigmodel.cn/api/paas/v4/",
  "apiKeyEnv": "BIGMODEL_API_KEY"
}

Revisa los nombres de los campos según tu versión. El patrón siempre es:

Proveedor compatible con OpenAI
URL base: BigModel
Modelo: glm-5.1
Autenticación: tu clave

Si ya usabas otro proveedor compatible OpenAI, este cambio es rápido.

Paso 3: entiende lo que Claude Code está haciendo entre bastidores

Claude Code envía solicitudes de completado de chat al estilo OpenAI a BigModel.

Solicitud ejemplo:

curl https://open.bigmodel.cn/api/paas/v4/chat/completions \
  -H "Authorization: Bearer $BIGMODEL_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "glm-5.1",
    "messages": [
      {
        "role": "user",
        "content": "Escribe una función en Python que elimine las líneas duplicadas de un archivo."
      }
    ],
    "max_tokens": 2048,
    "temperature": 0.7
  }'

Por eso funciona la integración: Claude Code sólo necesita un backend que hable el formato OpenAI.

Para ejemplos de Python y Node, revisa cómo usar la API de GLM-5.1.

Paso 4: ejecuta primero una pequeña tarea de validación

Antes de usar un repositorio grande, prueba una tarea sencilla como:

Escribe un script de Python que escanee una carpeta en busca de archivos JSON e imprima los inválidos.

Refactoriza esta función para mejorar la legibilidad y añade pruebas.

Lee este archivo, explica qué hace y sugiere dos mejoras seguras.

Verifica:

Claude Code acepta la configuración
La autenticación de BigModel funciona
GLM-5.1 devuelve respuestas correctas
El uso de herramientas en Claude Code funciona bien

Si todo pasa, puedes probar con un repositorio real.

Mejores tareas para GLM-5.1 dentro de Claude Code

GLM-5.1 es más fuerte en sesiones de codificación iterativas.

Buenas opciones:

Corrección de errores en varios archivos
Exploración y resumen de repositorios
Generación y reparación de pruebas
Refactorización iterativa
Ajuste de rendimiento
Bucles de agente largos
Mejoras basadas en benchmarks

Opciones menos ideales:

Escritura pura de texto
Preguntas cortas
Ediciones muy pequeñas
Flujos donde el estilo nativo de Claude es más valioso que el backend

El mejor uso es cuando quieres productividad sostenida en sesiones largas.

GLM-5.1 vs Claude dentro de Claude Code

No hay un ganador absoluto. Claude destaca en ediciones que requieren mucho razonamiento y navegación compleja. GLM-5.1 es competitivo en tareas de tipo SWE-Bench y sesiones impulsadas por herramientas.

Haz pruebas en la misma tarea y compara:

Calidad del código
Número de turnos requeridos
Tasa de aprobación de pruebas
Uso de herramientas
Latencia
Costo/cuota

Si GLM-5.1 logra buena calidad y menor costo, puede ser tu backend ideal. Si Claude sigue siendo mejor para tu flujo, mantente con él.

Problemas comunes y soluciones

Autenticación fallida

Verifica la clave en una solicitud curl
Asegúrate de que la variable de entorno esté cargada
El archivo de configuración debe apuntar al campo correcto
Revisa espacios y comillas

Modelo no encontrado

El nombre debe ser exactamente:

glm-5.1

Claude Code ignora el proveedor personalizado

Guarda la configuración
Reinicia Claude Code
Haz primero una prueba pequeña

Solicitudes OK pero mala calidad de salida

GLM-5.1 es más fuerte en sesiones largas, no en prompts simples.

Reduce la temperatura
Da instrucciones claras y específicas
Úsalo en tareas iterativas

La cuota se agota muy rápido

Las horas pico cuestan más en BigModel. Si puedes, programa sesiones largas en horas de menor actividad.

Probando la integración con Apidog

Para validar la configuración, usa Apidog para probar el endpoint de BigModel antes o junto con Claude Code.

Flujo recomendado:

Define el endpoint de completación de chat de BigModel en Apidog
Guarda una solicitud con el modelo glm-5.1
Prueba una respuesta normal
Prueba errores como autenticación inválida o límites de velocidad
Simula el endpoint para pruebas internas sin consumir cuota

Esto es útil si construyes envoltorios alrededor de herramientas de IA o enrutamiento entre modelos. Con Smart Mock y Test Scenarios de Apidog puedes validar la API sin depender del editor.

¿Deberías usar GLM-5.1 con Claude Code?

Sí, si quieres probar un modelo fuerte sin perder el flujo de Claude Code.

Vale la pena intentarlo si:

Usas Claude Code a diario
Haces sesiones de codificación de varios pasos
Buscas otra opción de backend
Eres sensible al costo
Quieres comparar varios modelos en el mismo flujo

Si tu trabajo es más de edición corta y razonamiento, Claude sigue siendo excelente. Pero si buscas productividad sostenida, GLM-5.1 es un buen candidato.

Conclusión

Usar GLM-5.1 con Claude Code es más sencillo de lo que parece. Sólo necesitas la clave API de BigModel, la URL base y el modelo glm-5.1. La API compatible con OpenAI hace que el enrutamiento sea familiar y fácil de probar.

La razón real para hacerlo es comprobar si GLM-5.1 es suficientemente bueno en tu flujo real de Claude Code como para justificarlo como backend. Si haces codificación larga, correcciones iterativas y flujos intensivos en herramientas, vale la pena probarlo.

Preguntas frecuentes

¿Puede Claude Code usar GLM-5.1 directamente?

Sí, si tu configuración admite proveedores personalizados compatibles con OpenAI.

¿Qué URL base debo usar?

https://open.bigmodel.cn/api/paas/v4/

¿Qué nombre de modelo debo introducir?

glm-5.1

¿Necesito un SDK GLM especial?

No. GLM-5.1 funciona vía la API de BigModel compatible con OpenAI.

¿Puedo usar GLM-5.1 con otras herramientas de codificación también?

Sí. El mismo patrón funciona para herramientas como Cline, Roo Code y OpenCode.

¿Es GLM-5.1 mejor que Claude para todas las tareas de codificación?

No. Depende del flujo de trabajo; prueba ambos en tus tareas reales y compara resultados.

Cómo usar la API GLM-5.1: guía completa con ejemplos de código

Roobia — Wed, 08 Apr 2026 05:50:14 +0000

TL;DR

GLM-5.1 está disponible vía la API de BigModel en https://open.bigmodel.cn/api/paas/v4/. La API es compatible con OpenAI: misma estructura de endpoint, formato de solicitud y patrón de streaming. Solo necesitas una cuenta de BigModel, una clave API y el nombre del modelo glm-5.1. Esta guía muestra autenticación, primera solicitud, streaming, llamada a herramientas y cómo probar tu integración con Apidog.

Prueba Apidog hoy

Introducción

GLM-5.1 es el modelo agéntico insignia de Z.AI, lanzado en abril de 2026. Es #1 en SWE-Bench Pro y supera a GLM-5 en los principales benchmarks de codificación. Si desarrollas asistentes de codificación IA, agentes autónomos o apps que requieren tareas de larga duración, integra GLM-5.1.

La API es 100% compatible con OpenAI. Si ya usas GPT-4 o Claude, cambia solo la URL base y el nombre del modelo. No necesitas aprender un nuevo SDK ni lidiar con formatos de respuesta diferentes.

💡 Tip: El mayor reto con APIs agénticas es la prueba. Los agentes pueden ejecutar cientos de llamadas a herramientas en minutos, difícil de testear sin consumir cuota. Apidog soluciona esto: define toda la secuencia de solicitudes, simula respuestas para cada estado y verifica que tu integración maneje correctamente streaming, llamadas a herramientas y errores antes de producción.

Requisitos previos

Antes de empezar:

Cuenta en BigModel en bigmodel.cn
Clave API desde la consola de BigModel, sección “API Keys”
Python 3.8+ o Node.js 18+ (los ejemplos cubren ambos)
SDK de OpenAI o librerías estándar requests/fetch

Configura la clave API como variable de entorno:

export BIGMODEL_API_KEY="tu_clave_api_aquí"

Nunca incluyas claves API en el código fuente.

Autenticación

Cada solicitud requiere este encabezado:

Authorization: Bearer TU_CLAVE_API

La clave API de BigModel tiene formato xxxxxxxx.xxxxxxxxxxxxxxxx (dos bloques separados por punto). No uses el prefijo sk-, pero funciona igual en el header.

URL base

https://open.bigmodel.cn/api/paas/v4/

El endpoint de chat:

POST https://open.bigmodel.cn/api/paas/v4/chat/completions

Tu primera solicitud

Usando curl

curl https://open.bigmodel.cn/api/paas/v4/chat/completions \
  -H "Authorization: Bearer $BIGMODEL_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "glm-5.1",
    "messages": [
      {
        "role": "user",
        "content": "Escribe una función en Python que encuentre todos los números primos hasta n usando la Criba de Eratóstenes."
      }
    ],
    "max_tokens": 1024,
    "temperature": 0.7
  }'

Usando Python (requests)

import os
import requests

api_key = os.environ["BIGMODEL_API_KEY"]

response = requests.post(
    "https://open.bigmodel.cn/api/paas/v4/chat/completions",
    headers={
        "Authorization": f"Bearer {api_key}",
        "Content-Type": "application/json"
    },
    json={
        "model": "glm-5.1",
        "messages": [
            {
                "role": "user",
                "content": "Escribe una función en Python que encuentre todos los números primos hasta n usando la Criba de Eratóstenes."
            }
        ],
        "max_tokens": 1024,
        "temperature": 0.7
    }
)

result = response.json()
print(result["choices"][0]["message"]["content"])

Usando el SDK de OpenAI (recomendado)

Puedes usar el SDK oficial de OpenAI para Python con URL base personalizada:

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ["BIGMODEL_API_KEY"],
    base_url="https://open.bigmodel.cn/api/paas/v4/"
)

response = client.chat.completions.create(
    model="glm-5.1",
    messages=[
        {
            "role": "user",
            "content": "Escribe una función en Python que encuentre todos los números primos hasta n usando la Criba de Eratóstenes."
        }
    ],
    max_tokens=1024,
    temperature=0.7
)

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

Este método es ideal: el SDK maneja reintentos, timeouts y parsing de respuestas automáticamente.

Formato de respuesta

La estructura es idéntica a OpenAI:

{
  "id": "chatcmpl-abc123",
  "object": "chat.completion",
  "created": 1744000000,
  "model": "glm-5.1",
  "choices": [
    {
      "index": 0,
      "message": {
        "role": "assistant",
        "content": "def sieve_of_eratosthenes(n):\n    ..."
      },
      "finish_reason": "stop"
    }
  ],
  "usage": {
    "prompt_tokens": 32,
    "completion_tokens": 215,
    "total_tokens": 247
  }
}

Accede al texto con: result["choices"][0]["message"]["content"].

El campo usage muestra el conteo de tokens. Monitorea esto para controlar tu consumo, ya que GLM-5.1 cobra 3x cuota durante horas pico (14:00-18:00 UTC+8).

Respuestas en streaming

Para peticiones largas (por ejemplo, generación de código), habilita streaming para recibir tokens conforme se generan.

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ["BIGMODEL_API_KEY"],
    base_url="https://open.bigmodel.cn/api/paas/v4/"
)

stream = client.chat.completions.create(
    model="glm-5.1",
    messages=[
        {
            "role": "user",
            "content": "Explica cómo funciona un índice B-tree en una base de datos, con un ejemplo de código."
        }
    ],
    stream=True,
    max_tokens=2048
)

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

print()  # Nueva línea al finalizar

Cada chunk contiene solo los nuevos tokens. El último chunk tiene finish_reason: "stop" (o "length" si se alcanza el límite).

Streaming con requests raw

import os
import json
import requests

api_key = os.environ["BIGMODEL_API_KEY"]

response = requests.post(
    "https://open.bigmodel.cn/api/paas/v4/chat/completions",
    headers={
        "Authorization": f"Bearer {api_key}",
        "Content-Type": "application/json"
    },
    json={
        "model": "glm-5.1",
        "messages": [{"role": "user", "content": "Escribe una ordenación por mezcla en Python."}],
        "stream": True,
        "max_tokens": 1024
    },
    stream=True
)

for line in response.iter_lines():
    if line:
        line = line.decode("utf-8")
        if line.startswith("data: "):
            data = line[6:]
            if data == "[DONE]":
                break
            chunk = json.loads(data)
            delta = chunk["choices"][0]["delta"]
            if "content" in delta:
                print(delta["content"], end="", flush=True)

Llamada a herramientas

GLM-5.1 soporta llamada a herramientas: permite que el modelo solicite ejecución de funciones durante la conversación. Es clave para flujos agénticos (ejecutar código, buscar en bases de datos, llamar APIs externas, etc).

Definiendo herramientas

import os
import json
from openai import OpenAI

client = OpenAI(
    api_key=os.environ["BIGMODEL_API_KEY"],
    base_url="https://open.bigmodel.cn/api/paas/v4/"
)

tools = [
    {
        "type": "function",
        "function": {
            "name": "run_python",
            "description": "Ejecuta código Python y devuelve la salida. Usa esto para probar, perfilar o comparar código.",
            "parameters": {
                "type": "object",
                "properties": {
                    "code": {
                        "type": "string",
                        "description": "El código Python a ejecutar"
                    }
                },
                "required": ["code"]
            }
        }
    },
    {
        "type": "function",
        "function": {
            "name": "read_file",
            "description": "Lee el contenido de un archivo",
            "parameters": {
                "type": "object",
                "properties": {
                    "path": {
                        "type": "string",
                        "description": "Ruta del archivo a leer"
                    }
                },
                "required": ["path"]
            }
        }
    }
]

response = client.chat.completions.create(
    model="glm-5.1",
    messages=[
        {
            "role": "user",
            "content": "Escribe una función para calcular números de Fibonacci, pruébala para n=10 y muéstrame la salida."
        }
    ],
    tools=tools,
    tool_choice="auto"
)

message = response.choices[0].message
print(f"Razón de finalización: {response.choices[0].finish_reason}")

if message.tool_calls:
    for tool_call in message.tool_calls:
        print(f"\nHerramienta llamada: {tool_call.function.name}")
        print(f"Argumentos: {tool_call.function.arguments}")

Manejo de las respuestas de llamadas a herramientas

Cuando GLM-5.1 solicita una herramienta, ejecuta la función y retorna el resultado en el siguiente mensaje:

import subprocess

def execute_tool(tool_call):
    """Ejecuta la herramienta y devuelve el resultado."""
    name = tool_call.function.name
    args = json.loads(tool_call.function.arguments)

    if name == "run_python":
        result = subprocess.run(
            ["python3", "-c", args["code"]],
            capture_output=True,
            text=True,
            timeout=10
        )
        return result.stdout or result.stderr

    elif name == "read_file":
        try:
            with open(args["path"]) as f:
                return f.read()
        except FileNotFoundError:
            return f"Error: archivo {args['path']} no encontrado"

    return f"Herramienta desconocida: {name}"


def run_agent_loop(user_message, tools, max_iterations=20):
    """Ejecuta un bucle completo de agente con llamadas a herramientas."""
    messages = [{"role": "user", "content": user_message}]

    for i in range(max_iterations):
        response = client.chat.completions.create(
            model="glm-5.1",
            messages=messages,
            tools=tools,
            tool_choice="auto",
            max_tokens=4096
        )

        message = response.choices[0].message
        messages.append(message.model_dump())

        if response.choices[0].finish_reason == "stop":
            return message.content

        if response.choices[0].finish_reason == "tool_calls":
            for tool_call in message.tool_calls:
                tool_result = execute_tool(tool_call)
                messages.append({
                    "role": "tool",
                    "tool_call_id": tool_call.id,
                    "content": tool_result
                })

    return "Se alcanzó el número máximo de iteraciones"


result = run_agent_loop(
    "Escribe una implementación de Quicksort, pruébala con una lista aleatoria de 1000 enteros y reporta el tiempo.",
    tools
)
print(result)

Este patrón explota la fortaleza agéntica de GLM-5.1: el modelo decide cuándo llamar herramientas y sigue hasta terminar o encontrar solución.

Parámetros clave

Parámetro	Tipo	Predeterminado	Descripción
`model`	cadena	requerido	Usa `"glm-5.1"`
`messages`	array	requerido	Historial de conversación
`max_tokens`	entero	1024	Tokens a generar (hasta 163.840)
`temperature`	flotante	0.95	Aleatoriedad (0.0-1.0)
`top_p`	flotante	0.7	Muestreo de núcleo (recom. 0.7 para codificación)
`stream`	booleano	falso	Habilitar streaming
`tools`	array	nulo	Definiciones de funciones para llamada a herramientas
`tool_choice`	cadena/objeto	"auto"	`"auto"`, `"none"`, o herramienta específica
`stop`	cadena/array	nulo	Secuencias de detención personalizadas

Configuración recomendada para tareas de codificación:

{
    "model": "glm-5.1",
    "temperature": 1.0,
    "top_p": 0.95,
    "max_tokens": 163840  # contexto completo para ejecuciones agénticas largas
}

Para generación determinista, baja la temperatura a 0.2-0.4.

Usando GLM-5.1 con asistentes de codificación

Puedes enrutar Claude Code, Cline, Kilo Code y otros asistentes IA vía la API de BigModel para usar GLM-5.1 como backend de codificación.

Configuración de Claude Code

En ~/.claude/settings.json:

{
  "model": "glm-5.1",
  "baseURL": "https://open.bigmodel.cn/api/paas/v4/",
  "apiKey": "tu_clave_api_de_bigmodel"
}

Configuración de Cline / Roo Code

En la configuración de VS Code o la extensión Cline:

{
  "cline.apiProvider": "openai",
  "cline.openAIBaseURL": "https://open.bigmodel.cn/api/paas/v4/",
  "cline.openAIApiKey": "tu_clave_api_de_bigmodel",
  "cline.openAIModelId": "glm-5.1"
}

Consumo de cuota

GLM-5.1 usa sistema de cuotas Z.AI:

Horas pico (14:00-18:00 UTC+8): 3x cuota
Fuera de pico: 2x cuota
Promoción hasta abril 2026: 1x fuera de pico

Para cargas pesadas, programa tareas largas fuera de horas pico.

Probando la API de GLM-5.1 con Apidog

Testear integraciones agénticas requiere simular múltiples tipos de respuesta: normal, streaming, llamadas a herramientas, errores, etc. Hacerlo contra la API real gasta cuota y depende de conexión activa.

Smart Mock de Apidog permite definir estos estados y probar sin tocar la API real.

Configurando el endpoint mock

En Apidog, crea un endpoint: POST https://open.bigmodel.cn/api/paas/v4/chat/completions
Añade una expectativa de mock para respuesta estándar:

{
  "id": "chatcmpl-test123",
  "object": "chat.completion",
  "created": 1744000000,
  "model": "glm-5.1",
  "choices": [
    {
      "index": 0,
      "message": {
        "role": "assistant",
        "content": "def sieve(n): ..."
      },
      "finish_reason": "stop"
    }
  ],
  "usage": {
    "prompt_tokens": 32,
    "completion_tokens": 120,
    "total_tokens": 152
  }
}

Añade expectativa para llamada a herramienta:

{
  "id": "chatcmpl-tool456",
  "object": "chat.completion",
  "created": 1744000001,
  "model": "glm-5.1",
  "choices": [
    {
      "index": 0,
      "message": {
        "role": "assistant",
        "content": null,
        "tool_calls": [
          {
            "id": "call_abc",
            "type": "function",
            "function": {
              "name": "run_python",
              "arguments": "{\"code\": \"print(2+2)\"}"
            }
          }
        ]
      },
      "finish_reason": "tool_calls"
    }
  ],
  "usage": {
    "prompt_tokens": 48,
    "completion_tokens": 35,
    "total_tokens": 83
  }
}

Añade respuesta de límite de tasa (HTTP 429):

{
  "error": {
    "message": "Límite de tasa excedido. Inténtalo de nuevo después de 60 segundos.",
    "type": "rate_limit_error",
    "code": "rate_limit_exceeded"
  }
}

Probando el bucle completo del agente

Usa los Escenarios de Prueba de Apidog para encadenar solicitudes:

Paso 1: POST a /chat/completions con el mensaje inicial, verifica 200 y finish_reason == "tool_calls"
Paso 2: POST con el resultado de la herramienta, verifica 200 y finish_reason == "stop"
Paso 3: Extrae el contenido final y verifica que incluye el código esperado

Así pruebas todo el ciclo agéntico sin consumir cuota. Para manejo de errores, simula mocks que devuelvan 429 y verifica el reintento.

Con Escenarios de Prueba puedes pasar variables entre pasos (por ejemplo, IDs de llamada a herramienta) y simular el flujo real de un agente.

Manejo de errores

La API usa códigos HTTP estándar:

Estado	Significado	Acción
200	Éxito	Procesa la respuesta
400	Solicitud incorrecta	Revisa el formato de tu solicitud
401	No autorizado	Verifica tu clave API
429	Límite de tasa	Reintenta tras el valor del header `Retry-After`
500	Error servidor	Reintenta con retroceso exponencial
503	Servicio no disp.	Reintenta con retroceso exponencial

Ejemplo de reintentos:

import time
import requests

def call_with_retry(payload, max_retries=3):
    for attempt in range(max_retries):
        try:
            response = requests.post(
                "https://open.bigmodel.cn/api/paas/v4/chat/completions",
                headers={"Authorization": f"Bearer {os.environ['BIGMODEL_API_KEY']}",
                         "Content-Type": "application/json"},
                json=payload,
                timeout=120
            )

            if response.status_code == 429:
                retry_after = int(response.headers.get("Retry-After", 60))
                print(f"Límite de tasa. Esperando {retry_after}s...")
                time.sleep(retry_after)
                continue

            response.raise_for_status()
            return response.json()

        except requests.exceptions.Timeout:
            wait = 2 ** attempt
            print(f"Tiempo de espera en el intento {attempt + 1}. Reintentando en {wait}s...")
            time.sleep(wait)

    raise Exception("Número máximo de reintentos excedido")

Para ejecuciones largas, usa un timeout alto (120-300s). El modelo puede requerir ese tiempo para generar un archivo de código o analizar benchmarks.

Conclusión

La API compatible con OpenAI de GLM-5.1 permite integraciones rápidas si ya usas GPT o Claude. La diferencia es el endpoint (open.bigmodel.cn) y el sistema de cuotas en vez de tokens.

Para aplicaciones agénticas con muchas llamadas a herramientas, la optimización a largo plazo de GLM-5.1 es clave. Combínalo con pruebas robustas usando Smart Mock y Escenarios de Prueba de Apidog para asegurar que tu integración cubre todos los casos antes de producción.

Consulta más detalles sobre GLM-5.1 y benchmarks en la descripción general del modelo GLM-5.1. Aprende sobre flujos de trabajo de agentes IA y pruebas en cómo funciona la memoria del agente de IA.

Preguntas frecuentes

¿La API de GLM-5.1 es compatible con OpenAI?

Sí. El formato de solicitud, respuesta, streaming y llamadas a herramientas es igual que OpenAI. Usa el SDK oficial de OpenAI apuntando a https://open.bigmodel.cn/api/paas/v4/.

¿Cuál es el nombre del modelo?

Usa "glm-5.1".

¿Cómo funciona el precio?

GLM-5.1 usa cuotas: 3x durante horas pico (14:00-18:00 UTC+8), 2x fuera de pico, 1x promocional fuera de pico hasta abril 2026.

¿Cuál es la longitud máxima de contexto?

200.000 tokens de entrada; salida máxima: 163.840 tokens. Para tareas largas, usa max_tokens grande (32.768+).

¿Soporta llamadas a funciones/herramientas?

Sí. Especifica herramientas con esquema type: "function" en el array tools y maneja respuestas con finish_reason: "tool_calls".

¿Cómo pruebo la API sin gastar cuota?

Usa Smart Mock de Apidog para simular respuestas de éxito, herramienta, límite de tasa y errores. Ejecuta tu suite de pruebas contra el mock y solo valida con la API real al final.

¿Dónde están los pesos del modelo GLM-5.1?

En HuggingFace bajo zai-org/GLM-5.1, licencia MIT, compatibles con vLLM y SGLang para inferencia local.

Las 8 Mejores Herramientas Gratuitas para Documentación de APIs (2026)

Roobia — Wed, 08 Apr 2026 04:27:07 +0000

Si eres un desarrollador, sabes que la documentación de tus APIs es fundamental. La documentación de API conecta tu código con los usuarios y puede definir el éxito o fracaso de tu proyecto. Documentar bien una API atrae clientes, mejora la satisfacción del usuario, reduce el soporte y optimiza la colaboración.

Prueba Apidog hoy

Sin embargo, crear documentación de API de calidad puede ser tedioso y propenso a errores si lo haces manualmente. Es esencial mantener la documentación actualizada, clara, precisa y fácil de usar para el equipo y los usuarios. Además, debe estar bien estructurada y ser interactiva para facilitar la adopción y el uso.

Por eso es clave elegir una herramienta de documentación de API que te permita generar, gestionar y publicar documentación de manera eficiente. Usar la solución adecuada te ahorra tiempo, esfuerzo y recursos, y mejora la experiencia de desarrollo y el resultado final para tus usuarios.

💡 ¿Buscas una forma sencilla de crear, gestionar y compartir documentación de API?

La plataforma todo en uno de Apidog permite generar documentación clara y completa para mantener a tu equipo sincronizado y tus APIs accesibles. Convierte especificaciones en documentación interactiva de forma instantánea, facilitando la colaboración y la incorporación de usuarios.

Pero, ¿cómo elegir la herramienta de documentación de API adecuada para tu proyecto? Hay muchas opciones, cada una con características, ventajas y limitaciones distintas. Aquí tienes una comparativa práctica de las 8 mejores herramientas gratuitas para documentación de API, evaluadas bajo estos criterios clave:

Facilidad de uso: ¿Qué tan sencillo es crear y mantener la documentación?
Funcionalidad: ¿Qué herramientas ofrece para mejorar la documentación?
Personalización: ¿Qué control tienes sobre el diseño y el contenido?
Integración: ¿Se integra bien con tus flujos y herramientas actuales?
Soporte: ¿La comunidad y el soporte son confiables?

Herramienta de Documentación de API Top 1: Apidog

Apidog es una de las herramientas más completas para documentar APIs. Su enfoque está en la rapidez y la facilidad de uso. Puedes crear y compartir documentación profesional y moderna en minutos, usando Markdown o el panel visual para diseñar endpoints.

Apidog está optimizado para la documentación de API, permitiendo agregar ejemplos de código, búsqueda, feedback, y analítica sin complicaciones. El editor inteligente mantiene la documentación clara y estructurada, y las opciones de personalización y exportación son muy flexibles. Puedes ver un ejemplo de documentación creada con Apidog.

Ventajas prácticas de Apidog:

Velocidad: Documentación lista en minutos.
Interactividad: Ejemplos de código, búsqueda y feedback integrados.
Soporte activo: Comunidad y equipo de soporte receptivos.
Gratis para empezar: Prueba todas las funciones sin coste inicial.

Herramienta de Documentación de API Top 2: Apiary

Apiary permite diseñar, prototipar, testear y documentar APIs de forma colaborativa. Usa API Blueprint o Swagger para escribir la documentación y genera automáticamente un sitio web interactivo. Además, simula respuestas, valida solicitudes y monitoriza el rendimiento de tus APIs.

A tener en cuenta:

Solo un proyecto API en el plan gratuito y debe ser público.
Personalización y exportación limitadas.
Comunidad activa, pero soporte oficial mejorable.

Herramienta de Documentación de API Top 3: Slate

Slate es open source y permite documentar APIs en Markdown para generar una web elegante y responsiva. Admite navegación tipo sidebar, ejemplos de código y búsqueda, y puedes personalizar con HTML, CSS y JS.

Consideraciones técnicas:

Necesitas instalar, mantener y desplegar Slate por tu cuenta.
No tiene soporte oficial, solo comunidad en GitHub.
Requiere conocimientos técnicos para personalización avanzada.

Herramienta de Documentación de API Top 4: Postman

Postman es una suite completa para desarrollo, testeo y documentación de APIs. Organiza requests en colecciones y genera documentación a partir de ellas, con opciones de compartir y testeo automatizado.

Puntos clave:

Documentación menos intuitiva, requiere actualización manual.
Opciones de personalización y exportación limitadas.
Comunidad activa, soporte oficial mejorable.

Herramienta de Documentación de API Top 5: Docusaurus

Docusaurus es open source y permite crear sitios de documentación en Markdown, con control de versiones, búsqueda, localización y blog.

Detalles técnicos:

No enfocada a APIs, requiere escribir documentación manualmente o con herramientas externas.
Necesita instalación y despliegue propio.
Comunidad en GitHub, sin soporte oficial.

Herramienta de Documentación de API Top 6: Read the Docs

Read the Docs es una plataforma para alojar documentación escrita en Markdown, reStructuredText o AsciiDoc. Genera y publica webs de documentación automáticamente, con búsqueda y control de versiones.

Aspectos prácticos:

No especializada en APIs.
Personalización y exportación limitadas.
Comunidad activa, soporte mejorable.

Herramienta de Documentación de API Top 7: Swagger UI

Swagger UI facilita la visualización e interacción con tus APIs usando especificaciones OpenAPI o Swagger. Permite probar endpoints y generar ejemplos de código desde la misma interfaz.

Consideraciones:

El editor requiere formato específico y no es muy intuitivo.
Opciones de personalización y exportación limitadas.

Herramienta de Documentación de API Top 8: Document360

Document360 es una herramienta intuitiva para documentar APIs y guías técnicas. Permite cargar OpenAPI, validar y mantener la documentación automáticamente al cambiar la especificación. Ofrece control de versiones similar a GitHub, edición colaborativa y evita sobrescritura de trabajos.

Permite personalizar la documentación según la marca, incluir tutoriales y guías, y ofrece búsqueda con IA para encontrar endpoints rápidamente. Los desarrolladores pueden generar ejemplos de código y mostrar logs paso a paso con detalles de fuente, fecha y estado.

Conclusión

La documentación de API es esencial para cualquier proyecto y puede marcar la diferencia entre el éxito y el fracaso. Elegir la herramienta adecuada facilita la creación, gestión y publicación de documentación profesional y útil.

En este artículo, exploraste las 8 mejores opciones gratuitas para documentar APIs, comparadas según facilidad de uso, funcionalidad, personalización, integración y soporte. Elige la que mejor se adapte a las necesidades técnicas de tu equipo y flujo de trabajo para optimizar resultados.

¿Qué es GLM-5.1? Explicación del nuevo modelo agente insignia de Z.AI

Roobia — Wed, 08 Apr 2026 04:07:10 +0000

TL;DR

GLM-5.1 es el modelo insignia de próxima generación de Z.AI, lanzado en abril de 2026. Está optimizado para ingeniería agentica: tareas de codificación de larga duración, bucles de optimización autónomos y proyectos de software complejos que requieren cientos de iteraciones. Es #1 en SWE-Bench Pro (58.4), lidera en Terminal-Bench 2.0 (69.0) y supera a GLM-5 en todos los principales benchmarks de codificación. Los pesos abiertos están disponibles bajo la Licencia MIT.

Prueba Apidog hoy

Introducción

La mayoría de modelos de IA se estancan tras unas pocas docenas de llamadas a herramientas. Hacen progreso rápido al inicio en tareas de codificación, pero luego producen rendimientos decrecientes, forzando supervisión manual o resultados subóptimos.

GLM-5.1 rompe ese patrón. Fue lanzado por Zhipu AI (Z.AI) en abril de 2026, pensado para tareas agenticas exigentes. Su punto fuerte no es solo el rendimiento en benchmarks a una pasada, sino la capacidad de mantener mejoras significativas durante más de 600 iteraciones, 8 horas y miles de llamadas a herramientas.

💡 Tip: Si trabajas con APIs de IA o flujos de agentes multi-paso, testear exhaustivamente GLM-5.1 es esencial. Los Escenarios de Prueba de Apidog te permiten definir cadenas de llamadas API que simulan flujos reales, verificando manejo correcto de salidas asíncronas, secuencias de herramientas y streaming desde GLM-5.1 antes de producción. Descarga Apidog gratis para seguir las pruebas de esta guía.

¿Qué es GLM-5.1?

GLM-5.1 es un modelo de lenguaje grande de Zhipu AI, lanzado en su plataforma de desarrolladores Z.AI en abril de 2026. "GLM" significa General Language Model, arquitectura desarrollada desde 2021.

GLM-5.1, sucesor de GLM-5 (2025), se centra casi exclusivamente en capacidades agenticas: trabajar de forma autónoma en tareas largas sin intervención humana frecuente ni estancamientos de rendimiento.

No es un modelo de razonamiento general, escritura creativa o chatbot multipropósito. Z.AI lo posiciona específicamente para ingeniería agentica: construir software, ejecutar bucles de optimización, iterar código y resolver problemas que requieren esfuerzo sostenido.

Los pesos están disponibles en Hugging Face bajo Licencia MIT. Puedes correrlo localmente con vLLM o SGLang, o acceder vía API BigModel o la plataforma Z.AI.

Rendimiento de GLM-5.1 en benchmarks

Z.AI publicó benchmarks comparativos con GLM-5, GPT-5.4, Claude Opus 4.6 y Gemini 3.1 Pro en ingeniería de software, razonamiento y tareas agenticas.

Ingeniería de software

Benchmark	GLM-5.1	GLM-5	GPT-5.4	Opus 4.6	Gemini 3.1 Pro
SWE-Bench Pro	58.4	55.1	57.7	57.3	54.2
NL2Repo	42.7	35.9	41.3	49.8	33.4
Terminal-Bench 2.0	69.0	56.2	75.1	65.4	68.5
CyberGym	68.7	48.3	—	66.6	—

GLM-5.1 es #1 en SWE-Bench Pro, el estándar para tareas autónomas de ingeniería de software. En Terminal-Bench 2.0, GPT-5.4 tiene mejor puntuación, pero GLM-5.1 supera ampliamente a GLM-5.

NL2Repo mide generación de repositorios a largo plazo: Claude Opus lidera, pero GLM-5.1 mejora claramente respecto a GLM-5.

Razonamiento

Benchmark	GLM-5.1	GLM-5	GPT-5.4	Opus 4.6	Gemini 3.1 Pro
HLE (con herramientas)	52.3	50.4	52.1*	53.1*	51.4*
AIME 2026	95.3	95.4	98.7	95.6	98.2
HMMT Nov. 2025	94.0	96.9	95.8	96.3	94.8
GPQA-Diamond	86.2	86.0	92.0	91.3	94.3

GLM-5.1 es competitivo pero no líder en razonamiento; GPT-5.4 y Gemini 3.1 Pro destacan en AIME 2026 y GPQA-Diamond. Su fortaleza es la codificación y tareas agenticas.

Tareas agenticas

Benchmark	GLM-5.1	GLM-5	GPT-5.4	Opus 4.6	Gemini 3.1 Pro
BrowseComp (contexto)	79.3	75.9	82.7	84.0	85.9
MCP-Atlas (Público)	71.8	69.2	67.2	73.8	69.2
Tool-Decathlon	40.7	38.0	54.6	47.2	48.8
Agentic	68.0	62.0	—	—	—

En MCP-Atlas, GLM-5.1 es líder (71.8). En BrowseComp y Tool-Decathlon obtiene resultados medios. El benchmark Agentic muestra una mejora clara respecto a GLM-5.

Lo que hace diferente a GLM-5.1: optimización a largo plazo

Más allá de los benchmarks a una pasada, GLM-5.1 está diseñado para mantener mejoras sostenidas en ejecuciones largas, evitando el estancamiento típico de otros modelos.

Escenario 1: optimización de base de datos vectorial en +600 iteraciones

Z.AI probó GLM-5.1 optimizando búsqueda vectorial sobre SIFT-1M. El modelo partió de un esqueleto en Rust y debía maximizar QPS (>95% recuperación), sin límite de iteraciones.

Resultados: el mejor otro modelo logró 3,547 QPS (Claude Opus 4.6). GLM-5.1, tras 600+ iteraciones y 6,000+ llamadas a herramientas, alcanzó 21,500 QPS (~6x más).

La mejora fue por transiciones estructurales, no solo tweaks superficiales. Ejemplo: en la iteración 90 cambió de escaneo completo a cluster IVF con compresión, saltando de ~3,500 a 6,400 QPS; en la 240, pipeline de dos etapas, subiendo a 13,400 QPS. Estas transiciones se dispararon tras analizar registros y cuellos de botella.

Escenario 2: optimización de kernel GPU en +1,000 turnos

Z.AI comparó GLM-5.1, GLM-5 y Claude Opus 4.6 optimizando kernels CUDA desde código PyTorch.

GLM-5.1 logró un speedup de 3.6x. Claude Opus 4.6 lideró con 4.2x y mostró margen de mejora al final. GLM-5 se estancó antes y más bajo. De nuevo, GLM-5.1 mantiene progreso durante más turnos.

Ventana de contexto y especificaciones técnicas

GLM-5.1 soporta ventana de contexto de 200K tokens, ideal para agentes que acumulan historial de herramientas, archivos, logs y errores en sesiones largas.

Especificación	Valor
Ventana de contexto	200,000 tokens
Salida máxima	163,840 tokens
Arquitectura	Transformador autorregresivo (GLM)
Licencia	MIT (pesos abiertos)
Marcos de inferencia	vLLM, SGLang
Pesos del modelo	HuggingFace (zai-org)

Disponibilidad y precios

GLM-5.1 se puede usar de tres maneras:

API BigModel (bigmodel.cn): API principal para desarrolladores (glm-5.1). Sistema de cuotas. Durante horas pico (14:00-18:00 UTC+8) consume 3x cuota, no pico 2x (promoción 1x hasta fin de abril 2026).
Plan de Codificación GLM (Z.AI): Plan de suscripción para asistentes de codificación IA. GLM-5.1 está disponible para todos los suscriptores; solo cambia el nombre del modelo en la config. Compatible con Claude Code, Cline, Kilo Code, Roo Code, OpenCode, Droid. Desde $10/mes.
Despliegue local: Pesos en HuggingFace zai-org/GLM-5.1. Correr con vLLM o SGLang. Documentación en GitHub.

GLM-5.1 vs GLM-5: qué realmente cambia

GLM-5 ya era potente en codificación. GLM-5.1 amplía la ventana útil de trabajo.

No es solo mejor en la primera pasada (+3-7 puntos en benchmarks), sino que sigue progresando en tareas largas donde GLM-5 se estanca. Ejemplo: en búsqueda vectorial, GLM-5 quedó en 8-10K QPS, GLM-5.1 llegó a 21.5K. En optimización GPU, GLM-5 terminó más bajo y antes. En tareas complejas, GLM-5 produce un esqueleto y se detiene.

Claude Opus 4.6 aún lidera en optimización GPU kernel y BrowseComp.

GLM-5.1 vs competidores

GLM-5.1 vs Claude Opus 4.6

GLM-5.1 lidera en SWE-Bench Pro (58.4 vs 57.3) y CyberGym (68.7 vs 66.6). Claude Opus 4.6 lidera en NL2Repo, optimización GPU y BrowseComp. El acceso API de Claude es más caro; GLM-5.1 es más accesible para bucles de agente de alto volumen.

GLM-5.1 vs GPT-5.4

GPT-5.4 es mejor en Terminal-Bench 2.0 y razonamiento. GLM-5.1 lidera en SWE-Bench Pro y MCP-Atlas. Para desarrolladores en China o usando infraestructura china, acceder a BigModel con GLM-5.1 es más sencillo que obtener acceso a GPT-5.4.

GLM-5.1 vs Gemini 3.1 Pro

Gemini 3.1 Pro lidera en razonamiento y BrowseComp. GLM-5.1 lidera en SWE-Bench Pro, Terminal-Bench 2.0 y CyberGym. Para código, GLM-5.1 es más fuerte; para razonamiento general, Gemini tiene ventaja.

Casos de uso óptimos para GLM-5.1

Agentes de codificación autónomos: Tareas largas donde el modelo decide qué probar, ejecuta tests, analiza resultados y sigue sin checkpoints humanos frecuentes. Para detalles sobre gestión de memoria de agentes, revisa cómo funciona la memoria del agente de IA. La ventana de 200K tokens y la optimización sostenida lo hacen ideal aquí.
Asistentes de codificación IA (Claude Code, Cline, Cursor): GLM-5.1 es compatible con el Plan de Codificación de Z.AI y herramientas como Claude Code, Kilo Code, Roo Code, etc. Si buscas un modelo potente sin el coste por token de Claude o GPT, usa BigModel.
Automatización de ingeniería de software (tipo SWE-Bench): Resolución de issues en GitHub, generación de PRs, automatización de bugs. El #1 en SWE-Bench Pro lo hace creíble para pipelines automatizadas.
Programación competitiva y optimización: Ajuste de kernels GPU, benchmarking de rendimiento, optimización de algoritmos donde el modelo puede experimentar y ajustar estrategias en base a resultados.
No recomendado para: Chatbots generales, escritura creativa, preguntas sobre documentos donde el razonamiento puro es más importante que la generación de código. Para esos casos, Gemini y GPT-5.4 son mejores.

Cómo probar GLM-5.1 hoy

Interfaz web: Usa el chat de Z.AI en z.ai, ya ejecuta GLM-5.1 por defecto. No necesitas clave API.
API: Crea cuenta en bigmodel.cn, genera tu clave API. La API es compatible con OpenAI, así que cualquier cliente GPT funciona. Usa el modelo glm-5.1.
Despliegue local: Pesos disponibles en huggingface.co/zai-org. Guía completa en el repo oficial: github.com/zai-org/GLM-5.1.
Documentación API y ejemplos: Consulta la guía de la API de GLM-5.1 para autenticación, ejemplos de código y tests.

Conclusión

GLM-5.1 supone un avance real respecto a GLM-5, especialmente en tareas agenticas de larga duración. Su #1 en SWE-Bench Pro y la demo de 600+ iteraciones en búsqueda vectorial lo posicionan como el modelo de pesos abiertos más sólido para flujos de codificación autónomos hoy.

No es el mejor en todo: Claude Opus 4.6 y GPT-5.4 lideran en razonamiento y algunas tareas agenticas, pero si quieres ejecutar agentes autónomos sin pagar precios de modelos cerrados, GLM-5.1 bajo Licencia MIT y API BigModel es una opción seria.

La combinación de pesos abiertos y licencia MIT permite ejecutarlo localmente, afinarlo y desplegarlo en tu infraestructura sin restricciones de uso.

Preguntas frecuentes

¿Qué significa GLM?

General Language Model, arquitectura desarrollada por Zhipu AI desde 2021, basada en relleno de espacios en blanco autorregresivo en vez del enfoque solo decodificador de GPT.

¿Es GLM-5.1 open source?

Sí. Pesos bajo Licencia MIT en HuggingFace zai-org/GLM-5.1. Puedes usarlo comercialmente, afinarlo y redistribuirlo.

¿Qué ventana de contexto soporta GLM-5.1?

200,000 tokens (~150,000 palabras), salida máxima 163,840 tokens.

¿Cómo se compara GLM-5.1 con DeepSeek-V3.2?

GLM-5.1 lidera en ingeniería de software según benchmarks de Z.AI. DeepSeek-V3.2 es competitivo en razonamiento. Para agentes de codificación, GLM-5.1 es el más fuerte según datos publicados.

¿Puedo usar GLM-5.1 con Claude Code o Cursor?

Sí. El Plan de Codificación de Z.AI soporta Claude Code, Cline, Kilo Code, Roo Code y OpenCode vía API BigModel. Actualiza el nombre del modelo en la config de tu asistente. Desde $10/mes.

¿Cómo accedo a GLM-5.1 por API?

Crea cuenta en bigmodel.cn, genera clave, usa modelo glm-5.1 en https://open.bigmodel.cn/api/paas/v4/chat/completions. Tutorial completo en la guía de la API de GLM-5.1.

¿GLM-5.1 es gratuito?

El chat de Z.AI (z.ai) es gratis. El acceso API usa sistema de cuotas con planes de pago. Uso fuera de horas pico facturado a 1x hasta fin de abril 2026 como promoción.

Grok Imagine sin restricciones: qué cambió y qué funciona realmente

Roobia — Wed, 08 Apr 2026 03:23:23 +0000

En pocas palabras

Grok Imagine eliminó su nivel gratuito el 19 de marzo de 2026 y endureció los filtros de contenido después de una controversia por deepfakes en enero. Los usuarios gratuitos ahora no obtienen ninguna generación de imágenes. SuperGrok (30 $/mes) restaura el acceso con límites más altos, pero el filtro NSFW sigue siendo aplicado. La API de xAI (grok-imagine-image) ofrece el acceso más flexible para desarrolladores. Si quieres una generación de imágenes local genuinamente sin censura, Stable Diffusion y FLUX son tus mejores opciones.

Prueba Apidog hoy

Introducción

Durante unos meses a finales de 2025, Grok Imagine fue el generador de imágenes más comentado en internet. Era gratuito. Era rápido. Y estaba notablemente menos filtrado que DALL-E o Midjourney. Eso cambió el 9 de enero de 2026, cuando xAI restringió la generación de imágenes a los suscriptores de pago después de que una ola de contenido deepfake se hiciera viral. Luego, el 19 de marzo de 2026, el nivel gratuito fue eliminado por completo.

Si buscas "Grok Imagine sin restricciones", probablemente quieras una de tres cosas: saber exactamente cuáles son los límites actuales, si puedes eludirlos o qué usar en su lugar. Este artículo cubre las tres.

💡 Desarrollo sobre la API de xAI: Si eres desarrollador y necesitas probar tu flujo de generación de imágenes sin gastar créditos en cada ejecución, usa Smart Mock de Apidog para simular la respuesta a POST /v1/images/generations. Así, podrás manejar estados de éxito, error y límite de velocidad en tu frontend sin tocar la API real. Descarga Apidog gratis para seguir la sección de pruebas más adelante en esta guía.

Qué pasó con el nivel gratuito de Grok Imagine

La cronología es importante porque la situación cambió tres veces en menos de tres meses:

Noviembre de 2025: xAI lanza Grok Imagine como parte del nivel gratuito de Grok en X (anteriormente Twitter). Usuarios gratuitos obtienen generaciones de imágenes limitadas por día usando el modelo aurora, que se posicionó alto en benchmarks de texto a imagen.
9 de enero de 2026: Tras un informe sobre imágenes deepfake explícitas de figuras públicas, xAI restringe la generación de imágenes a suscriptores de pago. Se añaden filtros de seguridad al modelo y los usuarios gratuitos pierden acceso. El cambio no se anunció públicamente.
19 de marzo de 2026: Se elimina el acceso gratuito por completo. Grok Imagine pasa a ser solo de pago.

En resumen: Grok Imagine era gratuito, fue abusado y xAI eliminó el nivel gratuito.

Cuáles son realmente los límites actuales (abril de 2026)

Grok Gratuito

No hay generación de imágenes. Si estás en el nivel gratuito, la pestaña Imaginar aparece en la UI, pero se bloquea al intentar generar.

SuperGrok (30 $/mes)

SuperGrok habilita la generación de imágenes con estos límites:

Característica	Límite
Generaciones de imágenes	~100/mes (no publicado oficialmente)
Generaciones de vídeo	Limitado a través de `grok-imagine-video`
Contenido NSFW	Bloqueado por filtro de seguridad
Caras humanas realistas	Parcialmente restringido
Figuras públicas	Restringido
Acceso a la API	No incluido (facturación separada)

El filtro de contenido en SuperGrok se aplica a nivel de modelo. xAI implementó un sistema de dos capas tras la controversia de enero: un protector de indicaciones (que analiza palabras clave y contexto) y un clasificador post-generación. Ambos se ejecutan en cada generación.

SuperGrok Heavy (300 $/mes)

Dirigido a usuarios intensivos y equipos. Más generaciones y menor latencia, pero la política de contenido es igual a la de SuperGrok. El precio más alto no implica menos restricciones.

API de xAI (acceso para desarrolladores)

La API es la vía más flexible. Haz un POST https://api.x.ai/v1/images/generations usando el modelo grok-imagine-image a 0,02 $ por imagen.

El filtro de contenido sigue activo vía API.
La política de uso prohíbe contenido sexual, deepfakes de personas reales y violaciones a sus términos.
El filtro es más permisivo para prompts artísticos/creativos que la UI de consumidor.
Tienes control programático total sobre lo que envías.

El filtro de contenido: qué bloquea y qué no

Bloquea: contenido sexual explícito, deepfakes de personas reales, violencia gráfica y contenido que involucre a menores.
Permite: la mayoría del arte y contenido creativo. Violencia estilizada, contenido sugerente no explícito, imágenes abstractas y surrealistas suelen pasar.

El filtro usa evaluación semántica, no solo palabras clave. Los prompts con lenguaje clínico, artístico o indirecto pueden obtener resultados diferentes frente a los directos.

Técnica de reformulación de la indicación

La principal técnica alternativa documentada es la reformulación artística. Describir una escena como pintura, escultura o arte en vez de explícitamente suele ser evaluado distinto. Esto puede mover contenido borderline de "bloqueado" a "permitido", pero no sirve para contenido explícitamente prohibido.

Grok Imagine vs otros generadores de imágenes: ¿qué es realmente menos restringido?

Si buscas menos restricciones, así se comparan las opciones principales:

Generador	Restricciones	Costo	¿Local?
Grok Imagine (SuperGrok)	Moderadas — bloquea lo explícito, permite lo artístico	30 $/mes	No
DALL-E 3 (ChatGPT Plus)	Estrictas — rechaza la violencia estilizada y la desnudez parcial	20 $/mes	No
Midjourney	Moderadas — similar a Grok, fuerte en lo artístico	10-120 $/mes	No
Adobe Firefly	Estrictas — solo seguro para uso comercial	5-55 $/mes	No
Stable Diffusion (local)	Ninguna — tú controlas todo	Costo del hardware	Sí
FLUX.1 (local)	Ninguna — tú controlas todo	Costo del hardware	Sí
ComfyUI + cualquier modelo	Ninguna — depende del modelo	Costo del hardware	Sí

Conclusión: Ningún generador en la nube es realmente "sin restricciones". Todos aplican políticas de contenido a nivel de API. Grok fue el menos filtrado a finales de 2025, pero ya no tras los cambios de enero.

Ejecutando la generación de imágenes localmente: la opción real sin restricciones

La generación local implica instalar el modelo en tu hardware y ejecutarlo, sin depender de una API externa. Sin política de contenido: lo que generas es solo tuyo.

Stable Diffusion

Stable Diffusion es el estándar. Los modelos SDXL y SD 3.5 tienen pesos abiertos y pueden ejecutarse en una GPU de consumidor.

Hardware mínimo: GPU con 8 GB de VRAM (ej. NVIDIA RTX 3060). En Mac, puede usarse CPU (más lento).
Opciones de interfaz:
- AUTOMATIC1111 (WebUI): basada en navegador. Fácil para principiantes.
- ComfyUI: editor de nodos, más control.
- Invoke AI: UI pulida, ideal para iterar.

Los modelos sin censura están disponibles en Hugging Face y CivitAI. Se cargan en cualquiera de las interfaces anteriores.

FLUX.1

FLUX de Black Forest Labs es más nuevo y produce imágenes más nítidas y realistas. FLUX.1-dev es gratis para uso no comercial; FLUX.1-schnell es totalmente abierto.

Corre en el mismo hardware que Stable Diffusion, pero usa más VRAM para imágenes grandes (idealmente 12 GB de VRAM).
Puede usarse vía ComfyUI o la librería Python diffusers:

from diffusers import FluxPipeline
import torch

pipe = FluxPipeline.from_pretrained(
    "black-forest-labs/FLUX.1-schnell",
    torch_dtype=torch.bfloat16
)
pipe.to("cuda")

image = pipe(
    "your prompt here",
    height=1024,
    width=1024,
    num_inference_steps=4,
    max_sequence_length=256,
).images[0]

image.save("output.png")

Sin clave de API. Sin filtro de contenido. El único límite es tu GPU.

Uso de la API de xAI para la generación de imágenes (guía para desarrolladores)

¿Quieres generación en la nube con más control que la UI? La API de xAI es el camino. Sigue filtrado, pero soporta acceso programático, procesamiento por lotes e integración con tus apps.

Autenticación

export XAI_API_KEY="your_key_here"

Obtén tu clave en console.x.ai. Necesitas método de pago antes de que funcione la generación de imágenes.

Tu primera solicitud de generación de imágenes

curl https://api.x.ai/v1/images/generations \
  -H "Authorization: Bearer $XAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "grok-imagine-image",
    "prompt": "a photorealistic mountain lake at sunrise, mist over the water",
    "n": 1,
    "response_format": "url"
  }'

La respuesta es sincrónica, con una URL:

{
  "created": 1744123456,
  "data": [
    {
      "url": "https://..."
    }
  ]
}

A diferencia de la API de vídeo (que es asíncrona), la de imágenes es síncrona: POST y recibes la URL en la misma respuesta (usualmente en 3-5 segundos).

Ejemplo en Python

import os
import requests

api_key = os.environ["XAI_API_KEY"]

response = requests.post(
    "https://api.x.ai/v1/images/generations",
    headers={
        "Authorization": f"Bearer {api_key}",
        "Content-Type": "application/json"
    },
    json={
        "model": "grok-imagine-image",
        "prompt": "a cyberpunk city street at night, neon reflections in rain puddles",
        "n": 1,
        "response_format": "url"
    }
)

data = response.json()
image_url = data["data"][0]["url"]
print(f"Image URL: {image_url}")

Parámetros

Parámetro	Tipo	Descripción
`model`	string	Debe ser `"grok-imagine-image"`
`prompt`	string	Tu descripción de texto
`n`	integer	Número de imágenes (1-4)
`response_format`	string	`"url"` o `"b64_json"`

Probando la API de imágenes de xAI con Apidog

Si tu app depende de Grok Imagine, necesitas manejar correctamente estos estados: generación exitosa, rechazos por política de contenido (HTTP 400), respuestas por límite de velocidad (HTTP 429) y tiempos de espera.

Probar esto en la API real cuesta 0,02 $ por llamada y requiere internet. Úsalo solo para integraciones finales, no para desarrollo de frontend.

Solución: Usa Smart Mock de Apidog. Así configuras el endpoint POST /v1/images/generations, defines respuestas simuladas para cada estado y haces que tu frontend consuma la simulación.

Configura la simulación de error de política de contenido:

En Apidog, crea un nuevo endpoint: POST https://api.x.ai/v1/images/generations
Añade una Expectativa de Simulación con condición en el cuerpo de solicitud.
Devuelve una respuesta 400 así cuando el prompt tenga contenido marcado:

{
  "error": {
    "message": "Your request was rejected as a result of our safety system.",
    "type": "invalid_request_error",
    "code": "content_policy_violation"
  }
}

Añade una segunda expectativa para respuestas 200 en prompts normales.

Ahora puedes probar tu código de manejo de errores sin activar el filtro real. Esto es clave para mostrar mensajes de error claros a los usuarios cuando sus prompts sean rechazados.

Para la configuración completa de pruebas en la API de generación de video, revisa la guía de la API de imagen a video de Grok y la guía de la API de texto a video de Grok.

Qué es el modelo grok-companion-ani (y por qué es diferente)

El modelo grok-companion-ani aparece en la documentación de xAI. Es diferente de grok-imagine-image, y está diseñado para animación de personajes e interacciones tipo compañero, no para generación general de imágenes.

Tiene precios y filtros de contenido diferentes.
No es una versión menos filtrada del generador de imágenes.

Alternativas a Grok Imagine que vale la pena conocer

Generación en la nube con menos restricciones que DALL-E:

Midjourney: Es la opción más fuerte para arte y creatividad. El filtro es similar al de Grok tras enero, pero la calidad en prompts complejos es superior. Desde 10 $/mes.
Leonardo AI: Política de contenido más permisiva que la mayoría para arte. El nivel gratuito es limitado pero útil para pruebas.
Ideogram: Ideal para texto en imagen, buen nivel gratuito. Menos relevante si buscas fotorrealismo.

Generación local:

FLUX.1-schnell: Para iterar rápido.
FLUX.1-dev: Para máxima calidad.
SDXL Turbo: Generación en tiempo real.

Todos pueden correr en hardware de consumidor y sin restricciones de contenido.

Conclusión

Grok Imagine tuvo una ventana breve como generador menos filtrado y gratuito. Esa ventana se cerró en enero de 2026 y finalizó en marzo cuando xAI eliminó el nivel gratuito.

Situación actual:

SuperGrok: Generación de imágenes en la nube con filtro moderado, 30 $/mes.
API de xAI: Acceso programático, 0,02 $ por imagen, mismo filtro.
Generación sin restricciones: Solo es posible localmente, ejecutando Stable Diffusion o FLUX en tu hardware.

La nube cambia sus filtros cada pocos meses. La generación local te da control total: tu hardware, tus modelos, tu salida.

Para una lista completa de modelos de IA gratuitos y abiertos que puedes ejecutar sin restricciones, revisa la guía de modelos de IA gratuitos.

Preguntas frecuentes

¿Grok Imagine todavía tiene un nivel gratuito?

No. Desde el 19 de marzo de 2026, necesitas suscripción de pago (SuperGrok 30 $/mes) para generar imágenes.

¿Se puede eludir el filtro de contenido de Grok Imagine?

No para contenido explícitamente prohibido (sexual, menores, violencia gráfica). Reformulación artística solo cambia el resultado para prompts borderline, pero no para violaciones claras de política.

¿Está Grok Imagine disponible vía API?

Sí. El modelo grok-imagine-image está en POST https://api.x.ai/v1/images/generations a 0,02 $ por imagen. Necesitas clave de API y método de pago.

¿Diferencia entre Grok Imagine y Grok imagen-a-vídeo?

Grok Imagine (grok-imagine-image) genera imágenes estáticas a partir de texto. Grok imagen-a-vídeo (grok-imagine-video) anima una imagen en un video corto. Son modelos, precios y endpoints distintos.

¿El mejor generador sin restricciones en 2026?

Para generación local: FLUX.1-schnell o SDXL. Ambos corren en GPUs de consumidor (8 GB+ VRAM), pesos abiertos y sin filtros de contenido.

¿Qué generador en la nube tiene menos restricciones?

Tras la actualización de Grok en enero 2026, el panorama es parejo. Midjourney y Leonardo AI son más permisivos que DALL-E o Adobe Firefly para arte. Ninguno permite contenido sexual explícito o deepfakes.

¿Cómo se compara Grok Imagine con Midjourney?

Después de enero 2026, políticas de contenido similares. Grok Imagine es más fotorrealista; Midjourney destaca en arte y prompts complejos. Midjourney desde 10 $/mes; Grok desde 30 $/mes (SuperGrok).

Cómo Automatizar tu Búsqueda de Empleo con Inteligencia Artificial Open Source (Guía Career-Ops)

Roobia — Tue, 07 Apr 2026 10:01:13 +0000

TL;DR

Career-Ops es un boilerplate gratuito y open source que convierte Claude Code en un sistema completo para automatizar la búsqueda de empleo técnico. Evalúa ofertas con puntuaciones A-F, genera CVs personalizados y optimizados para ATS, escanea automáticamente más de 45 portales de empresas y lleva el seguimiento en un panel tipo terminal. Su creador evaluó más de 740 ofertas y consiguió un puesto de Head of Applied AI usándolo.

Prueba Apidog hoy

Introducción

El seguimiento tradicional de solicitudes de empleo con hojas de cálculo es ineficiente y manual. Career-Ops automatiza el proceso: pegas una URL o descripción de puesto, el sistema evalúa la oferta, puntúa 10 dimensiones, genera un PDF personalizado y registra el resultado. Tú decides si aplicar.

Career-Ops no es un bot de aplicación masiva; su filosofía es filtrar y priorizar. Solo recomienda ofertas que realmente valen tu tiempo (puntuación >4.0/5). El proyecto alcanzó 11.9k estrellas en GitHub en menos de una semana.

💡 Consejo: Si necesitas probar endpoints de tus APIs en cada etapa de tu pipeline, los Escenarios de Prueba de Apidog permiten verificar cada llamada HTTP que Career-Ops hace a APIs de portales de empleo antes de pasar a producción. Más info en [internal: api-testing-tutorial].

¿Qué hace Career-Ops?

Career-Ops es un boilerplate para Claude Code. Clona el repo, añade tu CV en markdown, configura tu perfil YAML y abre Claude Code en ese directorio. Ejecuta comandos de barra para automatizar toda la pipeline.

Flujo principal:

Pegas una URL o descripción del puesto
        |
        v
Detección de arquetipo
(LLMOps / Agéntico / PM / SA / FDE / Transformación)
        |
        v
Motor de Evaluación A-F
(lee tu cv.md, puntúa 10 dimensiones)
        |
   +----+----+
   v    v    v
Informe  PDF  Seguimiento
 .md   .pdf  .tsv

Todo corre sobre Claude Code, que puede modificar sus propios scripts, pesos y modos bajo demanda.

Comandos principales

El punto de entrada es /career-ops con 14 modos clave:

/career-ops                      → Lista todos los comandos
/career-ops {descripción}        → Pipeline completa: evalúa + PDF + tracking
/career-ops scan                 → Escanea +45 portales para nuevas ofertas
/career-ops pdf                  → Genera CV optimizado para ATS para una oferta
/career-ops batch                → Evalúa 10+ ofertas en paralelo
/career-ops tracker              → Estado de la pipeline
/career-ops apply                → Rellena formularios de solicitud vía IA
/career-ops pipeline             → Procesa una cola de URLs
/career-ops contacto             → Redacta mensajes de contacto (ej. LinkedIn)
/career-ops deep                 → Investigación de empresa objetivo
/career-ops training             → Evalúa un curso/certificación
/career-ops project              → Evalúa un proyecto de portafolio

El flujo más usado es el auto-pipeline: pega cualquier URL de empleo y Career-Ops hace el resto. No necesitas elegir modo: pega la descripción, ejecuta, recibe evaluación y recursos.

Motor de puntuación A-F

El corazón de Career-Ops es su sistema de scoring, estructurado en 6 bloques:

A: Resumen del rol — Extrae título, equipo, antigüedad, skills. Clasifica arquetipo para aplicar la rúbrica adecuada.
B: Coincidencia de CV — Compara tu CV real con el puesto, razona sobre experiencia y gaps. Identifica dealbreakers.
C: Compensación — Investiga benchmarks salariales y arma argumentos de negociación.
D: Personalización — Redacta mensajes personalizados para carta de presentación/contacto.
E: Puntuación final (A-F) — Agrega los bloques previos y recomienda solo las ofertas >4.0/5.
F: Preparación para entrevistas (STAR+R) — Genera historias de tu CV en formato STAR con reflexión (“+R”) y las almacena en story-bank.md.

También genera scripts de negociación y estrategias para rechazar descuentos geográficos o usar ofertas competidoras.

Generación de PDF optimizado para ATS

El generador de PDF adapta tu CV a cada oferta. ¿Cómo funciona?

Lee la descripción y extrae los requisitos y keywords clave.
Reescribe tu experiencia para resaltar esas keywords (sin inventar nada).
Renderiza a PDF vía Playwright/Puppeteer usando plantilla HTML (Space Grotesk, DM Sans).

La plantilla es MIT, editable y forkeable.

# Genera CV personalizado para una oferta
/career-ops pdf

# O en pipeline completa
/career-ops {URL o descripción}

La salida va a output/, ignorado por Git para proteger tus datos.

Escaneo de portales a escala

Career-Ops incluye +45 empresas preconfiguradas:

Laboratorios de IA: Anthropic, OpenAI, Mistral, Cohere, LangChain, Pinecone
IA de Voz: ElevenLabs, PolyAI, Parloa, Hume AI, Deepgram, Vapi, Bland AI
Plataformas de IA: Retool, Airtable, Vercel, Temporal, Glean, Arize AI
LLMOps: Langfuse, Weights & Biases, Lindy, Cognigy, Speechmatics
Empresas: Salesforce, Twilio, Gong, Dialpad
Automatización: n8n, Zapier, Make.com
Europeas (DACH): Factorial, Attio, Tinybird, Clarity AI, Travelperk, +31 empresas DACH aportadas por la comunidad

El escáner usa Playwright para navegar páginas de empleo y consulta APIs de Greenhouse, Ashby, Lever y Wellfound. Ajusta empresas objetivo en portals.yml y ejecuta:

/career-ops scan

Las nuevas ofertas se agregan automáticamente a tu pipeline.

Procesamiento por lotes

Si tienes varias URLs para evaluar, usa el modo batch para procesarlas en paralelo:

# Coloca las URLs en jds/
# Luego ejecuta:
career-ops batch

Esto lanza workers claude -p en paralelo, cada uno evaluando una oferta. Los resultados se deduplican y fusionan en el tracking. El runner batch/batch-runner.sh maneja fallos y orquesta los trabajadores.

Procesar 20 ofertas manualmente puede llevar un día; en batch, menos de una hora.

Panel de control TUI (Go)

El tracking se guarda en data/applications.md (markdown table). El dashboard TUI (Go + Bubble Tea) muestra visualmente tu pipeline:

cd dashboard
go build -o career-dashboard .
./career-dashboard

Funciones: 6 pestañas de filtro, 4 modos de orden, agrupaciones, previsualización de informes y cambios de estado inline. Actualiza estados desde la TUI sin editar archivos.

Configuración en 15 minutos

Pasos rápidos para implementarlo:

# 1. Clona e instala
git clone https://github.com/santifer/career-ops.git
cd career-ops && npm install
npx playwright install chromium

# 2. Configura tu perfil
cp config/profile.example.yml config/profile.yml
# Edita profile.yml: nombre, ubicación, rol, salario, preferencias

# 3. Empresas objetivo
cp templates/portals.example.yml portals.yml
# Añade/elimina empresas

# 4. Añade tu CV
# Crea cv.md en la raíz y pega CV en markdown

# 5. Abre Claude Code
claude
# Ejemplos de prompts:
# "Cambia los arquetipos a roles de ingeniería backend"
# "Añade estas 5 empresas a portals.yml"
# "Actualiza mi perfil con este CV"

Claude puede modificar pesos, scripts y arquetipos editando los mismos archivos que usa el sistema.

Sistema de auto-actualización

Desde la v1.1.0, los archivos de sistema y usuario están separados. Las actualizaciones afectan solo a la capa de sistema; tus datos permanecen intactos.

# Buscar updates (se ejecuta al iniciar sesión)
node update-system.mjs check

# Aplicar actualización
node update-system.mjs apply

# Revertir si falla
node update-system.mjs rollback

Se crea una rama de backup antes de actualizar y se valida que tus archivos no se alteren.

Diferencias clave frente a otras herramientas

No es un bot de aplicación masiva ni solo un generador de CVs. Es un sistema de toma de decisión: te ayuda a decir NO y filtra ofertas que no encajan.
Razona sobre idoneidad real, no solo keywords. Compara tu experiencia de manera semántica, no por coincidencia de palabras.
Mejora con contexto. Cuanto más personalices tu perfil y añadas historias, más precisas son las evaluaciones.
Todo es local. Tus datos, CVs y PDFs nunca salen de tu máquina (excepto llamadas de API a Anthropic).

Limitaciones a considerar

Requiere Claude Code: Solo funciona con Claude Code y una cuenta de Anthropic.
Playwright no es infalible: Algunos portales cambian su HTML, lo que puede romper el scrapping.
Necesita calibración inicial: La primera configuración requiere dedicar ~1 hora a tu perfil.
El batch puede consumir créditos: Procesar muchos puestos en paralelo usa más tokens. Monitorea tu uso antes de lanzar lotes grandes.

Consulta [internal: how-ai-agent-memory-works] para entender la importancia del contexto y calibración en sistemas de IA.

¿Para quién es Career-Ops?

Está orientado a desarrolladores y técnicos que:

Buscan empleo activamente y quieren automatizar el seguimiento.
Aplican principalmente a empresas de IA y tecnología.
Valoran la evaluación inteligente por IA antes de aplicar.
Se sienten cómodos con la línea de comandos y edición de YAML.

No es ideal para usuarios no técnicos ni para quienes buscan una GUI o envío automatizado de solicitudes. Siempre decides tú si aplicar.

Primeros pasos

Clona el repo, añade tu CV y dedica una hora a configurar tu perfil con Claude. Ejecuta tu primera evaluación en una oferta relevante y ajusta tu perfil según resultados.

GitHub: github.com/santifer/career-ops

Licencia MIT. Contribuciones bienvenidas: abre un issue antes de enviar PRs.

Conclusión

Career-Ops es la pipeline de búsqueda de empleo open source más completa para desarrolladores. El motor de puntuación A-F, la generación automática de CVs, el procesamiento masivo en paralelo y el panel TUI en Go ofrecen un flujo de trabajo eficiente y enfocado.

La búsqueda de empleo es un problema de información, no de volumen. Career-Ops te ayuda a filtrar y priorizar donde realmente vale la pena aplicar.

Preguntas Frecuentes

¿Career-Ops cuesta algo?

Es gratis y MIT. Solo pagas por el uso de la API de Claude (evaluación completa ≈ $0.05 usando Claude 3.5 Haiku).

¿Se puede usar con otros modelos?

No directamente. Está construido para Claude Code; portarlo requiere reescribir definiciones de habilidades.

¿Cómo optimiza para ATS?

Extrae keywords de la oferta y reescribe tu experiencia para resaltar esas palabras en tu CV PDF, sin inventar experiencia. Usa fuentes seguras para ATS.

¿Qué portales soporta el escáner?

Greenhouse, Ashby, Lever, Wellfound, Workable, RemoteFront y páginas personalizadas via Playwright. +31 empresas DACH añadidas por la comunidad.

¿Mis datos están seguros?

Sí, todo es local y está ignorado por Git. Solo se envían datos a la API de Anthropic cuando se evalúa.

¿Puedo añadir mis propias empresas?

Sí, edita portals.yml. Si usan Greenhouse, Ashby o Lever, el escáner las detecta automáticamente. Para páginas personalizadas, define selectores de Playwright.

¿Cuánto tarda una evaluación?

2-4 minutos por oferta con PDF. En batch, 10 ofertas se procesan en paralelo y tardan sobre lo mismo que 1.

¿Qué es STAR+R?

Formato de entrevista (Situación, Tarea, Acción, Resultado + Reflexión). Career-Ops añade la columna de Reflexión para mostrar seniority.

¿Listo para profesionalizar tu búsqueda de empleo?

Implementa Career-Ops y automatiza tu pipeline hoy mismo.

Mejores Asistentes de Codificación Open Source en 2026: Alternativas Gratis a Cursor

Roobia — Tue, 07 Apr 2026 09:55:56 +0000

En resumen

Cursor cuesta 20 $/mes. Windsurf cuesta 15 $/mes. Cinco alternativas de código abierto ahora igualan el 80% de la funcionalidad de forma gratuita, incluyendo la codificación agéntica, ediciones de múltiples archivos y flexibilidad para usar tu propio modelo. Esta guía cubre las mejores, para qué sirve cada una y cómo elegir.

Prueba Apidog hoy

Introducción

Hace un año, "asistente de codificación de código abierto" significaba un complemento de autocompletado de código que sugería la siguiente línea. Hoy significa un entorno de codificación agéntico completo que puede leer tu base de código, escribir pruebas, ejecutar comandos de terminal e iterar sobre su propia salida.

La brecha entre las herramientas de pago y las alternativas gratuitas se ha cerrado drásticamente. Cursor sigue siendo el estándar de oro para la codificación agéntica, pero a 20 $/mes por desarrollador, se suma rápidamente para los equipos. Windsurf, a 15 $/mes, es una alternativa sólida. GitHub Copilot, a 10 $/mes, tiene la mayor adopción. Las tres son propietarias. No puedes auditar el código, no puedes autoalojarlas y estás limitado a sus elecciones de modelo.

Las herramientas de código abierto de este artículo te ofrecen flexibilidad de modelo, auditabilidad completa y cero tarifas de suscripción. La contrapartida es el tiempo de configuración y, en algunos casos, una experiencia de usuario más tosca.

💡Una cosa que ninguna de estas herramientas hace: probar las API que invoca tu código generado por IA. Ahí es donde entra Apidog. Una vez que un asistente de codificación de IA escribe un cliente REST o genera puntos finales con especificaciones OpenAPI, los escenarios de prueba de Apidog te permiten verificar esas integraciones antes de que lleguen a producción. Consulta [internal: api-testing-tutorial] para el flujo de trabajo de pruebas.

Por qué los asistentes de codificación de código abierto son viables en 2026

Tres cosas cambiaron.

Acceso a modelos: OpenAI, Anthropic y Google ofrecen acceso a la API de sus modelos de vanguardia. Una herramienta de código abierto con buena UX puede ofrecer el mismo modelo subyacente que Cursor; simplemente no viene con el envoltorio propietario. Herramientas como Continue.dev y Cline te permiten conectar directamente Claude 3.5 Sonnet, GPT-4o o Gemini 1.5 Pro.

Modelos locales: Ollama facilitó la ejecución de Qwen2.5-Coder, DeepSeek-Coder-V2 y Code Llama localmente. Para bases de código sensibles donde no puedes enviar código a una API externa, los modelos locales ahora son realmente utilizables para tareas de codificación.

Arquitectura de agente: la API de uso de herramientas de Claude y la llamada de funciones de GPT-4o estandarizaron cómo funcionan los agentes de codificación. Los frameworks de código abierto pueden replicar el mismo bucle de leer-archivo/escribir-archivo/ejecutar-terminal que impulsa el modo de agente de Cursor.

Los 5 mejores asistentes de codificación de código abierto

1. Continue.dev

Qué es: una extensión de VS Code y JetBrains que añade barra lateral de chat, ediciones en línea y preguntas y respuestas con conocimiento de la base de código. Es la opción de código abierto más madura.

Ideal para: desarrolladores que desean una experiencia similar a Cursor en VS Code sin abandonar su configuración existente. Ideal para equipos que quieren controlar qué modelo utilizan.

Configuración rápida:

Instala Continue.dev desde el marketplace de VS Code.
Añade tu clave API de OpenAI, Anthropic, Gemini o instancia local de Ollama.
Comienza a usarlo inmediatamente; no requiere cuenta.

Lo que puedes hacer:

Chat con contexto e indexación completa de la base de código.
Ediciones en línea con Ctrl+I.
Búsqueda @codebase en todo el repositorio.
Comandos de barra y proveedores de contexto personalizados.
Compatible con más de 20 proveedores de modelos.

Limitaciones:

No tiene ejecución de terminal incorporada ni bucle de agente autónomo.
Es un asistente, no un agente. Apruebas manualmente cada cambio.

Costo: gratuito. Autoalojamiento o uso de tus propias claves API.

	Cursor	Continue.dev
Precio	20 $/mes	Gratuito
Soporte VS Code	Sí	Sí
Soporte JetBrains	No	Sí
Flexibilidad modelo	Limitada	Completa
Modo agente	Sí	Parcial
Ideal para	Codificación agéntica completa	Edición asistida con control de modelo

2. Aider

Qué es: un agente de codificación basado en terminal que utiliza git como su interfaz principal. Describe lo que quieres, Aider lee los archivos relevantes, realiza cambios y los commitea.

Ideal para: ingenieros de backend que trabajan en la terminal y desean un agente autónomo ejecutable en CI o servidores remotos.

Configuración rápida:

Instala con:

   pip install aider-chat

Inicia desde la raíz de tu proyecto:

   aider --model claude-3-5-sonnet-20241022

Lo que puedes hacer:

Ediciones autónomas de múltiples archivos con commits de git.
Soporte para Claude, GPT-4o, Gemini y modelos locales.
Ejecuta en modo totalmente automático con el flag --yes.
Lee la estructura del repositorio para entender el código.
Entrada de voz y benchmarking integrado (aider-bench).

Limitaciones:

Solo terminal, sin integración IDE.
Revisar cambios grandes puede ser incómodo por falta de vista visual de diferencias.

Costo: gratuito. Solo pagas el uso de la API del modelo.

Ejemplo práctico (automatiza fixing de tests fallidos en CI):

- nombre: Ejecutar Aider para arreglar pruebas
  run: |
    aider --model gpt-4o \
          --message "Arreglar las pruebas fallidas en test_api.py" \
          --yes \
          --no-git

3. Cline

Qué es: extensión de VS Code que ejecuta un ciclo de agente completo con uso de herramientas. Cline puede leer y escribir archivos, ejecutar comandos de terminal, navegar por la web y controlar tu navegador. Es el equivalente más cercano al modo agente completo de Cursor.

Ideal para: desarrolladores que buscan tareas autónomas y de varios pasos gestionadas dentro de VS Code.

Configuración rápida:

Instala desde el marketplace de VS Code.
Añade tu clave API.
Inicia nueva tarea.

Lo que puedes hacer:

Ciclo agéntico completo: leer, escribir, ejecutar, navegar.
Modo de aprobación: aprueba cada acción antes de ejecutarse, o activa aprobación automática.
Flexibilidad de modelo: Claude, GPT-4o, Gemini, Bedrock, Vertex, Ollama local.
Seguimiento de costos por tarea.
Inyección de prompt de sistema personalizado.

Limitaciones:

Puede resultar costoso con modelos premium en tareas largas porque cada paso envía el contexto completo.
Vigila tus costos.

Costo: gratuito. Pagas al proveedor del modelo.

4. Modo

Qué es: IDE de código abierto (lanzado en abril de 2026), alternativo a Cursor, Kiro y Windsurf. IDE completo sobre el núcleo de VS Code con IA integrada.

Ideal para: desarrolladores que quieren un IDE dedicado con IA sin suscripción. Proyecto joven, pero prometedor.

Configuración rápida:

Clona desde GitHub:

   git clone https://github.com/mohshomis/modo.git
   cd modo
   npm install && npm run build

Lo que puedes hacer:

Compatibilidad total con el ecosistema de extensiones de VS Code.
Chat de IA y autocompletado integrados.
Agnóstico de modelo.
Código abierto y autoalojable.

Limitaciones:

Proyecto reciente, menos probado que Continue o Cline.
Solo instalación manual; aún no está en el Marketplace de VS Code.

Costo: gratuito.

5. Void editor

Qué es: fork de VS Code que añade capacidades nativas de IA sin extensiones. Aspira a ser el "Cursor de código abierto".

Ideal para: quienes buscan la experiencia completa de Cursor sin suscripción y prefieren un fork en vez de una extensión.

Configuración rápida:

Descarga desde voideditor.com.
Abre tu proyecto.
Configura tu modelo.

Lo que puedes hacer:

Chat e indexación nativos.
Edición de diferencias en línea.
Sistema de checkpoints (deshacer sesiones completas de IA).
Soporte para modelos locales vía Ollama.
Compatibilidad con extensiones de VS Code.

Limitaciones:

Los forks se quedan atrás respecto a actualizaciones oficiales de VS Code.
Algunas extensiones pueden ser incompatibles.

Costo: gratuito.

Tabla comparativa

Herramienta	Soporte IDE	Flexibilidad de modelo	Modo agente	Ideal para	Costo
Continue.dev	VS Code, JetBrains	Completa (más de 20 proveedores)	Parcial	Edición asistida, control de modelo en equipo	Gratuito
Aider	Terminal	Completa	Completo (agente de terminal)	Ingenieros de backend, automatización CI/CD	Gratuito
Cline	VS Code	Completa (Claude, GPT, Gemini, local)	Completo	Tareas autónomas de varios pasos en VS Code	Gratuito
Modo	IDE basado en VS Code	Completa	En desarrollo	IDE con IA primero sin suscripción	Gratuito
Void editor	Fork de VS Code	Completa	Parcial	UX similar a Cursor, código abierto	Gratuito

Cómo elegir el correcto

Usas VS Code y quieres chat tipo Cursor sin pagar: empieza con Continue.dev. Es el más pulido y con la comunidad más activa.
Desarrollador backend en terminal: usa Aider. Integración nativa con git, ideal para flujos CI/CD. Consulta [internal: how-to-build-tiny-llm-from-scratch] si estás creando backends IA.
Buscas un agente autónomo de varios pasos: Cline. Es el agente de código abierto más avanzado, ideal para automatización compleja.
Quieres un IDE de IA dedicado sin extensiones: prueba Void editor. Observa la evolución de Modo para el futuro.
Privacidad total del código (sin API externa): usa cualquiera con Ollama como backend. Qwen2.5-Coder-32B funciona bien en máquinas con >24 GB de VRAM y produce código de calidad.
Para equipos: Continue.dev y Cline permiten configuración compartida vía archivos versionados. Consulta [internal: rest-api-best-practices] para pruebas de API consistentes junto a tu stack de codificación.

Cómo Apidog encaja con los flujos de trabajo de codificación con IA

Los asistentes de codificación con IA generan código rápido, pero no verifican que las APIs funcionen realmente.

Por ejemplo: Continue.dev o Cline generan un cliente REST. Puede verse correcto sintácticamente, pero puede tener rutas incorrectas, encabezados faltantes o manejar solo casos de éxito. Estos errores solo aparecen al ejecutar contra APIs reales.

Soluciona esto con Apidog:

Importa el endpoint generado en Apidog (URL+metodo, o desde especificación OpenAPI).
Crea un Escenario de Prueba: encadena autenticación, request principal, aserción sobre respuesta.
Añade casos negativos: token caducado, cuerpo mal formado, límite de tasa.
Usa Smart Mock para simular APIs si no tienes entorno de staging.

Así obtienes velocidad de IA sin sacrificar pruebas de integración.

Ejemplo concreto: le pides a Cline que escriba un cliente de la API de GitHub. Genera una clase GitHubClient con métodos CRUD. En Apidog:

{
  "escenario": "Verificación de cliente de API de GitHub",
  "pasos": [
    {
      "nombre": "Crear issue",
      "método": "POST",
      "url": "https://api.github.com/repos/{owner}/{repo}/issues",
      "cabeceras": {"Autorización": "Bearer {{token}}"},
      "cuerpo": {"título": "Issue de prueba", "cuerpo": "Creado por escenario de prueba"},
      "aserciones": [
        {"campo": "estado", "operador": "igual a", "valor": 201},
        {"campo": "respuesta.número", "operador": "existe"}
      ]
    },
    {
      "nombre": "Listar issues (verificar que aparece el issue creado)",
      "método": "GET",
      "url": "https://api.github.com/repos/{owner}/{repo}/issues",
      "aserciones": [
        {"campo": "respuesta[0].número", "operador": "igual a", "valor": "{{steps[0].response.number}}"}
      ]
    }
  ]
}

Esto toma 5 minutos y detecta errores comunes de generación de código IA: método HTTP incorrecto, campos faltantes, paginación no manejada. Consulta [internal: how-ai-agent-memory-works] para probar APIs de agentes con estado.

Conclusión

El ecosistema de asistentes de codificación de código abierto es legítimamente bueno en 2026. No necesitas suscripción a Cursor para tener codificación agéntica, chat con contexto de la base de código y edición de múltiples archivos. Continue.dev, Aider y Cline cubren distintos flujos; Modo y Void editor valen la pena observarlos.

La pieza faltante son las pruebas. El código IA es rápido de escribir y fácil de romper. Combina tu asistente de código abierto con Apidog para verificar las integraciones de API generadas.

Preguntas frecuentes

¿Es Continue.dev tan bueno como Cursor?

Para chat y ediciones en línea, está cerca. Para tareas de agente autónomo (desarrollo completo sin intervención), el modo agente de Cursor sigue estando por delante. Si configuras Continue.dev con Claude 3.5 Sonnet o GPT-4o, la brecha se reduce.

¿Puedo usar asistentes de código abierto solo con modelos locales?

Sí. Todas las herramientas aquí son compatibles con Ollama, para modelos como Qwen2.5-Coder, DeepSeek-Coder-V2 o Code Llama. La calidad de modelos locales es menor en tareas complejas, pero suficiente para código repetitivo y refactorizaciones.

¿Cómo elijo un modelo para asistentes de código abierto?

Claude 3.5 Sonnet es mejor en tareas complejas y multi-step. GPT-4o es fuerte generando código y soporta llamadas de funciones. DeepSeek-Coder-V2 es la mejor alternativa open weight para código y se ejecuta localmente. Usa Claude o GPT-4o si el costo no es problema; DeepSeek si priorizas privacidad o volumen.

¿Es seguro usar Aider con el modo --yes?

Úsalo con precaución: aprueba automáticamente todos los cambios y commits. Ejecútalo en una rama, nunca en main, y revisa los diffs antes de fusionar. Útil en CI, pero no recomendado para desarrollo interactivo.

¿Qué es Kiro?

Kiro es un IDE de IA de AWS, anunciado en 2025. Basado en VS Code, como Cursor, pero con integración profunda con AWS. No es open source. Modo lo menciona como objetivo a reemplazar.

¿Pueden los equipos compartir la configuración de estas herramientas?

Sí. Continue.dev lee de .continue/config.json, Cline desde settings.json de VS Code, Aider desde .aider.conf.yml. Todo puede versionarse y estandarizarse en equipo.

¿Funcionan estas herramientas sin conexión?

Con modelos locales vía Ollama: sí, completamente offline. Con modelos vía API (Claude, GPT-4o): requieren internet. Void editor y Modo pueden configurarse para uso sin conexión con modelos locales.

Cómo construir un LLM desde cero: guía y aprendizaje

Roobia — Tue, 07 Apr 2026 04:32:46 +0000

TL;DR

Construir un modelo de lenguaje mínimo desde cero requiere menos de 300 líneas de Python. El proceso revela exactamente cómo funcionan la tokenización, la atención y la inferencia, lo que te convierte en un consumidor de API mucho mejor cuando integras LLMs de producción en tus aplicaciones.

Prueba Apidog hoy

Introducción

La mayoría de los desarrolladores tratan los modelos de lenguaje como cajas negras: envías texto, salen tokens y, en algún punto intermedio, ocurre la magia. Este enfoque es suficiente hasta que necesitas depurar una integración de API defectuosa, ajustar parámetros de muestreo o entender por qué tu modelo sigue alucinando datos estructurados.

GuppyLM, un proyecto que destacó en HackerNews, hace visibles los internos de los LLM. Es un transformador de 8.7M de parámetros escrito desde cero en Python, entrenable en menos de una hora en una GPU de consumo, y cuyo código cabe en un solo archivo. Su objetivo no es competir con GPT-4, sino desmitificar cómo funcionan realmente los LLM.

En este artículo verás cómo construir un pequeño LLM, qué hace cada componente y qué te aporta comprender los detalles internos cuando trabajas con APIs de IA.

💡 Si estás probando integraciones de API de IA, los Escenarios de prueba de Apidog te permiten verificar respuestas en streaming, afirmar la estructura de los tokens y simular finalizaciones de casos extremos sin consumir créditos de producción. Más sobre esto más adelante.

¿Qué hace que un modelo de lenguaje sea "pequeño"?

Un LLM de producción como GPT-4 tiene cientos de miles de millones de parámetros. Un LLM "pequeño" trabaja en el rango de 1M a 25M de parámetros. Ejemplos: GuppyLM (8.7M), nanoGPT de Karpathy (124M), MicroLM (1-2M).

Ventajas de los LLM pequeños:

Se entrenan en un portátil o Google Colab.
Caben en la memoria de la CPU.
Se pueden inspeccionar, modificar y depurar a nivel de pesos.

Limitaciones:

No manejan razonamientos complejos.
No generan texto coherente de formato largo de manera fiable.
No igualan la profundidad factual de los modelos de producción.

El valor está en comprender su funcionamiento, no en el resultado final.

Componentes principales: cómo funciona realmente un LLM

Antes de escribir código, debes conocer estos cuatro componentes principales:

Tokenizador

Convierte texto sin procesar a IDs de enteros. Por ejemplo, "Hello, world!" se convierte en [15496, 11, 995, 0]. Cada entero representa una subpalabra de un vocabulario fijo.

Relevancia en APIs: el conteo de tokens afecta latencia y costo. Entender cómo los tokenizadores dividen el texto ayuda a escribir prompts que se ajusten a la ventana de contexto y evitar truncamientos.

GuppyLM usa un tokenizador a nivel de caracteres. Modelos de producción usan BPE (Byte Pair Encoding) con vocabularios de 50K-100K tokens.

Capa de incrustación (Embedding layer)

Convierte IDs de tokens en vectores densos aprendidos (por ejemplo, 384 dimensiones en GuppyLM). Los tokens similares terminan agrupados en el espacio vectorial. Se añaden incrustaciones de posición para que el modelo conozca el orden de los tokens.

Bloques de transformador

Cálculo central del modelo. Cada bloque contiene:

Autoatención (Self-attention): cada token atiende a todos los demás en la secuencia para decidir cuáles son importantes para predecir el siguiente token. GuppyLM usa 6 cabezas de atención en 6 capas.
Red de avance (Feed-forward network): una MLP de dos capas con activación ReLU.

Cabezal de salida

Tras el bloque final, una capa lineal proyecta la representación de cada token al tamaño del vocabulario. Softmax convierte a probabilidades, se elige (o muestrea) el siguiente token y se repite el proceso.

Construyendo un LLM mínimo en Python

A continuación, un LLM mínimo funcional siguiendo el enfoque de GuppyLM, usando PyTorch.

import torch
import torch.nn as nn
import torch.nn.functional as F

# Hiperparámetros
VOCAB_SIZE = 256     # nivel de caracteres ASCII
D_MODEL = 128        # dimensión de embedding
N_HEADS = 4          # cabezas de atención
N_LAYERS = 3         # bloques transformador
SEQ_LEN = 64         # ventana de contexto
DROPOUT = 0.1

class SelfAttention(nn.Module):
    def __init__(self, d_model, n_heads):
        super().__init__()
        self.n_heads = n_heads
        self.head_dim = d_model // n_heads
        self.qkv = nn.Linear(d_model, 3 * d_model, bias=False)
        self.proj = nn.Linear(d_model, d_model, bias=False)
        self.dropout = nn.Dropout(DROPOUT)

    def forward(self, x):
        B, T, C = x.shape
        qkv = self.qkv(x).reshape(B, T, 3, self.n_heads, self.head_dim)
        q, k, v = qkv.unbind(dim=2)
        q = q.transpose(1, 2)
        k = k.transpose(1, 2)
        v = v.transpose(1, 2)
        # Máscara causal: cada token solo atiende a tokens previos
        scale = self.head_dim ** -0.5
        attn = (q @ k.transpose(-2, -1)) * scale
        mask = torch.triu(torch.ones(T, T, device=x.device), diagonal=1).bool()
        attn = attn.masked_fill(mask, float('-inf'))
        attn = F.softmax(attn, dim=-1)
        attn = self.dropout(attn)
        out = (attn @ v).transpose(1, 2).reshape(B, T, C)
        return self.proj(out)

class TransformerBlock(nn.Module):
    def __init__(self, d_model, n_heads):
        super().__init__()
        self.attn = SelfAttention(d_model, n_heads)
        self.ff = nn.Sequential(
            nn.Linear(d_model, 4 * d_model),
            nn.ReLU(),
            nn.Linear(4 * d_model, d_model),
            nn.Dropout(DROPOUT),
        )
        self.ln1 = nn.LayerNorm(d_model)
        self.ln2 = nn.LayerNorm(d_model)

    def forward(self, x):
        x = x + self.attn(self.ln1(x))
        x = x + self.ff(self.ln2(x))
        return x

class TinyLLM(nn.Module):
    def __init__(self):
        super().__init__()
        self.embed = nn.Embedding(VOCAB_SIZE, D_MODEL)
        self.pos_embed = nn.Embedding(SEQ_LEN, D_MODEL)
        self.blocks = nn.ModuleList([
            TransformerBlock(D_MODEL, N_HEADS) for _ in range(N_LAYERS)
        ])
        self.ln_f = nn.LayerNorm(D_MODEL)
        self.head = nn.Linear(D_MODEL, VOCAB_SIZE, bias=False)

    def forward(self, idx):
        B, T = idx.shape
        tok_emb = self.embed(idx)
        pos = torch.arange(T, device=idx.device)
        pos_emb = self.pos_embed(pos)
        x = tok_emb + pos_emb
        for block in self.blocks:
            x = block(x)
        x = self.ln_f(x)
        logits = self.head(x)
        return logits

# Inicializa y cuenta parámetros
model = TinyLLM()
total_params = sum(p.numel() for p in model.parameters())
print(f"Model size: {total_params:,} parameters")  # ~1.2M

Bucle de entrenamiento

import torch.optim as optim

def train(model, data, epochs=100, lr=3e-4):
    optimizer = optim.AdamW(model.parameters(), lr=lr)
    model.train()
    for epoch in range(epochs):
        # data: tensor de IDs de tokens, shape [batch, seq_len+1]
        x = data[:, :-1]   # entrada: todos menos el último
        y = data[:, 1:]    # objetivo: desplazado por 1
        logits = model(x)
        loss = F.cross_entropy(logits.reshape(-1, VOCAB_SIZE), y.reshape(-1))
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()
        if epoch % 10 == 0:
            print(f"Epoch {epoch}, loss: {loss.item():.4f}")

Inferencia (generación de texto)

@torch.no_grad()
def generate(model, prompt_ids, max_new_tokens=50, temperature=1.0, top_k=10):
    model.eval()
    ids = torch.tensor([prompt_ids])
    for _ in range(max_new_tokens):
        idx_cond = ids[:, -SEQ_LEN:]  # recorta a ventana de contexto
        logits = model(idx_cond)
        logits = logits[:, -1, :] / temperature  # solo último token
        # top-k sampling
        v, _ = torch.topk(logits, min(top_k, logits.size(-1)))
        logits[logits < v[:, [-1]]] = float('-inf')
        probs = F.softmax(logits, dim=-1)
        next_id = torch.multinomial(probs, num_samples=1)
        ids = torch.cat([ids, next_id], dim=1)
    return ids[0].tolist()

Lo que esto te enseña sobre el comportamiento de las APIs de IA

Construir un LLM mínimo da claridad sobre varios aspectos de consumo de APIs:

La temperatura y el muestreo son mecánicos, no mágicos

La temperatura divide los logits antes del softmax. Temperatura alta = salida más aleatoria; temperatura baja = salida más determinista. Si una API devuelve resultados inconsistentes con temperature=0.0, no es un bug: la temperatura cero real es un argmax codicioso, pero muchas APIs la redondean para evitar salidas degeneradas.

Las ventanas de contexto son límites estrictos

La línea idx_cond = ids[:, -SEQ_LEN:] muestra que al alcanzar el límite, el modelo descarta silenciosamente los tokens más antiguos. No asumas que la API recuerda todo el historial de conversación. Para más detalles, consulta [interno: cómo-funciona-la-memoria-del-agente-de-IA].

Los tokens de streaming son solo pasos de inferencia expuestos

Las APIs de streaming simplemente ejecutan el bucle de inferencia y envían cada token al flujo conforme se genera. Si el flujo se interrumpe, no se puede reanudar: hay que reiniciar.

Los logits explican por qué la salida estructurada es difícil

El modelo asigna probabilidad a cada token del vocabulario en cada paso. Generar JSON válido implica que cada token correcto gane en cada posición. Herramientas como Outlines y Guidance restringen la distribución de logits para imponer gramática. Cuando una API de IA ofrece "salida estructurada", internamente está haciendo esto.

Cómo probar integraciones de API de IA con Apidog

Comprender la inferencia de LLM permite escribir mejores pruebas de API. Los Escenarios de prueba de Apidog te permiten encadenar llamadas y afirmar la estructura de las respuestas.

Ejemplo para una API de chat en streaming:

Crea un Escenario de prueba en Apidog con el endpoint /v1/chat/completions.
Añade aserciones para la estructura de la respuesta:
- response.choices[0].finish_reason == "stop"
- response.usage.total_tokens < 4096
Agrega un paso que envíe la respuesta como contexto al siguiente turno, simulando conversación multi-turno.
Usa Smart Mock de Apidog para simular el endpoint de IA y probar el manejo de errores:
- simula finish_reason: "length" (truncamiento),
- finish_reason: "content_filter",
- y un timeout de red a mitad de transmisión.

De esta forma, puedes probar integraciones de IA sin consumir créditos de API en cada ejecución de CI. Consulta [interno: tutorial-de-pruebas-de-api] para más detalles sobre pruebas de API.

Probando aserciones de recuento de tokens

{
  "assertions": [
    {
      "field": "response.usage.completion_tokens",
      "operator": "less_than",
      "value": 512
    },
    {
      "field": "response.choices[0].finish_reason",
      "operator": "equals",
      "value": "stop"
    },
    {
      "field": "response.choices[0].message.content",
      "operator": "not_empty"
    }
  ]
}

Ejecuta esto en varios modelos (GPT-4o, Claude 3.5 Sonnet, Gemini 1.5 Pro) en un solo escenario de prueba para detectar diferencias de esquema antes de pasar a producción.

Avanzado: cuantificación y optimización de inferencia

Al tener un LLM pequeño en marcha, es útil entender dos técnicas usadas en producción.

Cuantificación

Por defecto, los pesos del modelo son float de 32 bits. La cuantificación los reduce a INT8 o INT4, disminuyendo el uso de memoria 4-8x con poca pérdida de precisión.

# Ejemplo: cuantificación dinámica INT8 en PyTorch
import torch.quantization
quantized_model = torch.quantization.quantize_dynamic(
    model, {nn.Linear}, dtype=torch.qint8
)

Las APIs de producción ejecutan modelos cuantificados. Cambios en la calidad de salida entre "versiones" de un mismo modelo suelen deberse a esto.

Caché KV

En el bucle de inferencia, recalculamos la atención para toda la secuencia. Los sistemas de producción almacenan en caché los pares clave-valor (KV) de los tokens previos para que cada token nuevo solo calcule atención sobre el último. Por eso el primer token de una respuesta streaming tarda más.

LLM pequeño vs. API de producción: ¿cuándo usar cada uno?

Caso de uso	LLM pequeño	API de producción
Aprendizaje de los internos	Lo mejor para	Excesivo
Prototipado de aplicación	Calidad insuficiente	Lo mejor para
Datos privados/sensibles	Buena opción	Depende del proveedor
Despliegue offline/en el borde	Viable	No posible
Sensible al costo, alto volumen	Posible con tradeoffs	Caro a escala
Tareas de alto razonamiento	No viable	Requerido

En la práctica: usa la API de producción para tu app, pero ejecuta un modelo pequeño para entender lo que sucede bajo el capó. No compiten. Consulta [interno: asistentes-de-codificación-de-código-abierto-2026] para herramientas que permiten "traer tu propio modelo".

Conclusión

Construir un LLM pequeño desde cero es cosa de un fin de semana. No es para producción, pero te da un modelo mental funcional sobre cómo opera cada modelo de lenguaje, desde GuppyLM hasta GPT-4o. Esa comprensión te ayuda a depurar integraciones de streaming, ajustar parámetros de muestreo y diseñar aserciones para tus pruebas de API de IA.

GuppyLM es un buen inicio: clónalo, entrénalo con cualquier dataset de texto y revisa el bucle de inferencia. Luego vuelve a tus integraciones de API de producción y las verás de otra manera.

Prueba los Escenarios de prueba de Apidog para llevar el mismo rigor a tus pruebas de API de IA que a cualquier backend.

Preguntas frecuentes

¿Cuántos parámetros necesita un LLM "pequeño" para generar texto coherente?

Alrededor de 10M-50M de parámetros con buen dataset pueden producir oraciones localmente coherentes. Por debajo de 1M, suele generar galimatías. GuppyLM (8.7M) funciona para conversaciones cortas en su dominio de entrenamiento (60 temas).

¿Puedo ejecutar un LLM pequeño sin GPU?

Sí. Modelos con menos de 100M de parámetros funcionan bien en CPU, aunque la inferencia es más lenta. El ejemplo anterior (1.2M) genera tokens en milisegundos en una laptop.

¿En qué dataset debo entrenar?

Modelos a nivel de caracteres funcionan bien con textos de Proyecto Gutenberg, Wikipedia o cualquier corpus plano. GuppyLM usa un dataset conversacional de 60K entradas en HuggingFace (arman-bd/guppylm-60k-generic). Para código, usa The Stack o CodeParrot.

¿Diferencia entre temperatura y muestreo top-k?

La temperatura escala la distribución de logits (aleatoriedad global). Top-k restringe el muestreo a los k tokens más probables antes de aplicar la temperatura. Se usan juntos: primero top-k filtra candidatos, luego la temperatura ajusta probabilidades.

¿Por qué mi LLM a veces se repite?

La repetición ocurre cuando el modelo asigna alta probabilidad a los tokens recién generados porque aparecen en el contexto. Las APIs suelen usar penalizaciones por repetición (repetition_penalty=1.1) para reducir esto.

¿Cuánto tiempo lleva entrenar un LLM pequeño?

El ejemplo anterior entrena para salida coherente en menos de 2 horas en una sola GPU (RTX 3060). GuppyLM entrena en Colab en similar tiempo. Modelos mayores (100M+) requieren multi-GPU y días de entrenamiento.

¿Cómo pasar de LLM pequeño a endpoint de API real rápido?

Exporta a formato GGUF con el script de llama.cpp y sírvelo con llama-server. Obtendrás un endpoint compatible con OpenAI localmente; apunta Apidog para pruebas. Consulta [interno: mejores-prácticas-de-rest-api].

¿Cómo manejan los LLM de producción el contexto más largo que su ventana de entrenamiento?

Técnicas como RoPE escalado, atención de ventana y generación aumentada por recuperación extienden el contexto efectivo. La arquitectura central no cambia; se modifican la codificación posicional y la ventana de atención.

Cómo Usar la API Seedance 2.0 en 2026

Roobia — Sat, 04 Apr 2026 12:59:45 +0000

En resumen

La API de Seedance 2.0 se lanzó el 2 de abril de 2026 a través de Volcengine Ark. Para generar un video, envía una tarea con una solicitud POST y luego consulta un endpoint GET hasta que el estado sea "succeeded". La API soporta texto a video, imagen a video, control de primer y último fotograma, referencias multimodales y generación de audio nativo. Un video de 5 segundos en 1080p cuesta aproximadamente $0.93. Descargue el video en las primeras 24 horas: la URL caduca después de ese tiempo.

Prueba Apidog hoy

Hypereal AI

Probar Hypereal AI

Introducción

El 2 de abril de 2026, la plataforma Volcengine Ark de ByteDance lanzó la API oficial de Seedance 2.0. Antes solo podía usarse desde la consola web. Si has visto tutoriales previos, probablemente muestran la interfaz gráfica. Este artículo aborda la API real para automatizar la generación de video desde código.

💡La API sigue el patrón de tarea asíncrona: POST para crear, obtienes un ID, luego haces polling con GET hasta terminar. Es recomendable probar este flujo de punta a punta antes de integrarlo en producción. Los escenarios de prueba de Apidog permiten encadenar el envío POST, extraer el ID, hacer polling con GET y validar que la respuesta final tenga la URL de video. Instala Apidog gratis para seguir los ejemplos de la sección correspondiente.

Este artículo cubre entradas soportadas, cómo leer el costo desde la respuesta y cómo manejar errores comunes en producción.

¿Qué es Seedance 2.0?

Seedance 2.0 es el modelo de generación de video de ByteDance en Volcengine Ark bajo los IDs doubao-seedance-2-0-260128 (estándar) y doubao-seedance-2-0-fast-260128 (rápido, menor calidad).

Novedades respecto a la v1.5:

Control de primer y último fotograma (proporciona imagen inicial y final)
Entradas multimodales: puedes enviar imágenes, videoclips y audio en la misma solicitud
Generación de audio nativo: diálogos, efectos, música, sonido ambiente
Sincronización labial en 8+ idiomas
Control de movimiento de cámara vía prompt (dolly, tracking, grúa)
Salida de hasta 15s, hasta 2K

Produce videos a 24 fps, con relación de aspecto 1:1 a 21:9 y resolución configurable.

Qué cambió: guía vs API oficial

Guías anteriores, como la de febrero 2026, explicaban la consola web. Desde abril 2026, puedes llamar la API desde cualquier lenguaje, automatizar pipelines y conectar Seedance con tus propias apps. Esta guía reemplaza el flujo manual de la interfaz para desarrolladores.

Requisitos previos

Abre una cuenta en volcengine.com.
Desde la consola de Ark, genera una clave API en:

   https://console.volcengine.com/ark/region:ark+cn-beijing/apikey

Exporta tu clave como variable de entorno:

   export ARK_API_KEY="tu-api-key-aquí"

Usa la clave como Bearer Token en cada solicitud:

   Authorization: Bearer YOUR_ARK_API_KEY

Las cuentas nuevas reciben créditos gratuitos (alcanza para unas 8 generaciones de 15s a 1080p).

Texto a video: su primera solicitud

La URL base de la API es:

https://ark.cn-beijing.volces.com/api/v3

Para enviar una tarea T2V, haz un POST a /v1/contents/generations/tasks.

Ejemplo cURL

curl -X POST "https://ark.cn-beijing.volces.com/api/v3/contents/generations/tasks" \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $ARK_API_KEY" \
  -d '{
    "model": "doubao-seedance-2-0-260128",
    "content": [
      {
        "type": "text",
        "text": "A golden retriever running through a sunlit wheat field, wide tracking shot, cinematic"
      }
    ],
    "resolution": "1080p",
    "ratio": "16:9",
    "duration": 5,
    "watermark": false
  }'

La API responde con un ID de tarea:

{"id": "cgt-2025xxxxxxxx-xxxx"}

Ejemplo en Python (SDK oficial)

Instala el SDK:

pip install volcenginesdkarkruntime

Envia una tarea:

import os
from volcenginesdkarkruntime import Ark

client = Ark(api_key=os.environ.get("ARK_API_KEY"))

resp = client.content_generation.tasks.create(
    model="doubao-seedance-2-0-260128",
    content=[
        {
            "type": "text",
            "text": "A golden retriever running through a sunlit wheat field, wide tracking shot, cinematic"
        }
    ],
    resolution="1080p",
    ratio="16:9",
    duration=5,
    watermark=False,
)

print(resp.id)

Guarda el ID para el polling.

El patrón de tarea asíncrona: enviar, sondear, descargar

La generación toma entre 60 y 120 segundos para un video de 5s a 1080p. El ciclo de vida de la tarea es:

queued -> running -> succeeded
                  -> failed
                  -> expired
                  -> cancelled

Haz polling al endpoint GET hasta que el estado cambie.

Bucle de polling completo en Python

import os
import time
import requests
from volcenginesdkarkruntime import Ark

client = Ark(api_key=os.environ.get("ARK_API_KEY"))

# Paso 1: Enviar tarea
resp = client.content_generation.tasks.create(
    model="doubao-seedance-2-0-260128",
    content=[
        {"type": "text", "text": "Aerial shot of a mountain lake at sunrise, slow dolly forward"}
    ],
    resolution="1080p",
    ratio="16:9",
    duration=5,
    watermark=False,
)

task_id = resp.id
print(f"Task submitted: {task_id}")

# Paso 2: Polling con backoff exponencial
wait = 10
while True:
    result = client.content_generation.tasks.get(task_id=task_id)
    status = result.status
    print(f"Status: {status}")

    if status == "succeeded":
        video_url = result.content.video_url
        print(f"Video URL: {video_url}")
        break
    elif status in ("failed", "expired", "cancelled"):
        print(f"Task ended with status: {status}")
        break

    time.sleep(wait)
    wait = min(wait * 2, 60)  # máximo 60s

# Paso 3: Descargar el video
if status == "succeeded":
    response = requests.get(video_url, stream=True)
    with open("output.mp4", "wb") as f:
        for chunk in response.iter_content(chunk_size=8192):
            f.write(chunk)
    print("Downloaded: output.mp4")

El backoff exponencial evita saturar la API; el límite de 60s mantiene el flujo práctico.

Imagen a video (I2V): animando una imagen estática

Para animar una imagen:

resp = client.content_generation.tasks.create(
    model="doubao-seedance-2-0-260128",
    content=[
        {
            "type": "text",
            "text": "The woman slowly turns her head and smiles at the camera"
        },
        {
            "type": "image_url",
            "image_url": {"url": "https://example.com/portrait.jpg"}
        }
    ],
    ratio="adaptive",
    duration=5,
    watermark=False,
)

Usa ratio: "adaptive" para conservar la relación de aspecto de la imagen. Máximo 30 MB por imagen y hasta 9 imágenes por solicitud.

Primer y último fotograma: controlando los puntos de inicio y fin

Seedance 2.0 soporta control de fotogramas de inicio y fin. Proporciona ambas imágenes y un prompt:

resp = client.content_generation.tasks.create(
    model="doubao-seedance-2-0-260128",
    content=[
        {
            "type": "text",
            "text": "The flower blooms from bud to full open, macro lens, soft light"
        },
        {
            "type": "image_url",
            "image_url": {"url": "https://example.com/flower-bud.jpg"}
        },
        {
            "type": "image_url",
            "image_url": {"url": "https://example.com/flower-open.jpg"}
        }
    ],
    ratio="adaptive",
    duration=8,
    watermark=False,
)

Incluye las imágenes en orden: primera, luego última. Usa return_last_frame: true para obtener el último fotograma y encadenar secuencias.

Referencia multimodal: combinando imágenes, video y audio

Puedes enviar múltiples tipos de entrada en el array content:

{"type": "text", "text": "..."}
{"type": "image_url", "image_url": {"url": "..."}}
{"type": "video_url", "video_url": {"url": "..."}}
{"type": "audio_url", "audio_url": {"url": "..."}}

Límites:

Hasta 9 imágenes (≤30MB c/u)
Hasta 3 videos (2–15s, ≤50MB c/u)
Hasta 3 audios (MP3, ≤15MB c/u)

Ejemplo:

resp = client.content_generation.tasks.create(
    model="doubao-seedance-2-0-260128",
    content=[
        {
            "type": "text",
            "text": "Match the visual style of the reference clip and add the provided background audio"
        },
        {
            "type": "image_url",
            "image_url": {"url": "https://example.com/style-reference.jpg"}
        },
        {
            "type": "video_url",
            "video_url": {"url": "https://example.com/motion-reference.mp4"}
        },
        {
            "type": "audio_url",
            "audio_url": {"url": "https://example.com/background-music.mp3"}
        }
    ],
    duration=10,
    ratio="16:9",
    watermark=False,
)

Si incluyes referencia de video la tarifa baja a V2V (~$3.90/millón tokens).

Generación de audio nativo

Para que Seedance genere audio junto con el video:

resp = client.content_generation.tasks.create(
    model="doubao-seedance-2-0-260128",
    content=[
        {
            "type": "text",
            "text": "A street musician plays guitar outside a cafe in Paris, crowds passing by, city sounds"
        }
    ],
    resolution="1080p",
    ratio="16:9",
    duration=10,
    generate_audio=True,
    watermark=False,
)

La generación conjunta de audio y video incrementa ligeramente el consumo de tokens.

Controlando la resolución, la relación de aspecto y la duración

resolution: "480p", "720p", "1080p", "2K" (default: "1080p")
ratio: "16:9", "9:16", "4:3", "3:4", "21:9", "1:1", "adaptive"
duration: entero de 4 a 15 (segundos, default: 5)

El modelo rápido (doubao-seedance-2-0-fast-260128) es útil para pruebas rápidas con menor calidad.

Elige Seedance 2.0 si necesitas audio+video nativo, control de fotogramas o entradas multimodales. Para tareas simples y bajo costo, usa el modelo rápido a 480p.

Leyendo el costo de la respuesta

Cuando una tarea termina, la respuesta incluye el campo usage:

{
  "usage": {
    "completion_tokens": 246840,
    "total_tokens": 246840
  }
}

Ejemplos:

15s 1080p ≈ 308,880 tokens
5s 1080p ≈ 102,960 tokens

Precios:

T2V/I2V 1080p: 46 yuanes/millón tokens (~$6.40)
V2V: 28 yuanes/millón tokens (~$3.90)

Calcula tu costo multiplicando completion_tokens por la tarifa correspondiente.

Importante: descargue el video en un plazo de 24 horas

La video_url caduca a las 24h de completada la tarea. Después, devuelve error 403 y el archivo se elimina. Descarga el archivo tan pronto como el estado sea "succeeded".

El campo execution_expires_after indica la expiración en segundos (registro de tarea: hasta 48h, pero la URL del video solo 24h). El historial de tareas está limitado a 7 días.

Cómo probar la API de Seedance con Apidog

El flujo asíncrono requiere múltiples pasos encadenados. Los escenarios de prueba de Apidog permiten automatizar todo el ciclo:

Paso 1: Crea un escenario de prueba

En Apidog, abre el módulo Pruebas y crea un escenario "Seedance 2.0 video generation".
Define ARK_API_KEY como variable de entorno.
Usa {{ARK_API_KEY}} donde corresponda.

Paso 2: Agrega la solicitud de envío

POST a https://ark.cn-beijing.volces.com/api/v3/contents/generations/tasks con el Bearer Token y el JSON del modelo.
Extrae el ID usando JSONPath $.id y guárdalo en TASK_ID.

Paso 3: Agrega un procesador de Espera

Añade un delay de 30s para dar tiempo al modelo.

Paso 4: Agrega la solicitud de polling en bucle For

Crea un bucle de máximo 20 iteraciones.
1. GET a /api/v3/contents/generations/tasks/{{TASK_ID}} con autorización.
2. Espera 10s.
3. Condición de ruptura: $.status == "succeeded" o $.status == "failed".

Paso 5: Agrega afirmaciones

Verifica que $.status sea "succeeded" y que $.content.video_url no esté vacío.

Al ejecutar el escenario, Apidog muestra cada paso, el ID, los estados y si las afirmaciones pasaron. Puedes importar endpoints Seedance desde un comando cURL.

Desglose de precios: lo que cuesta un video de 10 segundos

Seedance usa un modelo de pago por tokens. No hay mensualidades, solo pagas según consumo.

Tipo de tarea	Tarifa (por 1M tokens)
T2V / I2V a 1080p	46 yuanes (~$6.40)
V2V (referencia video)	28 yuanes (~$3.90)

Costos aproximados a 1080p:

Duración	Tokens aprox.	Costo (T2V/I2V)
5 segundos	~103,000	~0.66 yuanes / ~$0.93
10 segundos	~206,000	~9.48 yuanes / ~$1.32
15 segundos	~309,000	~14.21 yuanes / ~$1.97

Las cuentas nuevas tienen créditos de prueba para unos 8 videos de 15s. Usa esta cuota para experimentar. Menor resolución reduce mucho el consumo de tokens.

Errores comunes y soluciones

429 Demasiadas Solicitudes

Es límite de concurrencia, no de requests/minuto. Usa backoff exponencial (espera 10s, duplica en cada intento, máximo 60s).

estado: "failed"

Prompt prohibido, imagen dañada, archivo demasiado grande o parámetros inválidos. Revisa entradas y vuelve a enviar.

estado: "expired"

La tarea estuvo en cola demasiado tiempo. Reenvía la tarea.

403 en video_url

La URL caducó (más de 24h). El registro aún existe, pero debes regenerar el video.

Reproducibilidad de la semilla

Si guardas el parámetro seed, úsalo para intentar reproducir el mismo resultado.

Conclusión

La API de Seedance 2.0 permite automatizar generación de video avanzada: POST para crear tarea, polling hasta éxito, descarga inmediata. Entradas multimodales, audio nativo y control de fotogramas son ventajas clave. Configura tus tests en Apidog para detectar errores de lógica, extracción o expiración antes de ir a producción.

Preguntas Frecuentes (FAQ)

P: ¿Cuál es la diferencia entre doubao-seedance-2-0-260128 y doubao-seedance-2-0-fast-260128?

El modelo estándar da mayor calidad, recomendado para producción. El rápido es más veloz pero con menor calidad, ideal para iterar prompts.

P: ¿Puedo usar Seedance 2.0 fuera de China?

El endpoint está en Beijing. Puedes llamarlo desde fuera, pero la latencia será mayor. Revisa restricciones de tu cuenta Volcengine.

P: ¿Cómo encadeno varios clips en un video largo?

Usa return_last_frame: true para obtener el último fotograma y pásalo como primer fotograma de la siguiente solicitud. Une los clips con una herramienta de edición.

P: ¿La generación de audio nativo cuesta más?

Sí, incrementa ligeramente el consumo de tokens.

P: ¿Puedo establecer un webhook en lugar de polling?

Sí, proporciona callback_url en la solicitud. El API enviará el resultado cuando cambie el estado.

P: ¿Qué pasa si envío más de 9 imágenes?

Recibirás un error 400 de validación.

P: ¿La semilla garantiza reproducción exacta?

Acerca la salida, pero no es 100% garantizado si cambian parámetros o versión del modelo.

P: ¿Cómo hago seguimiento de gasto en varias tareas?

Lee completion_tokens en cada respuesta, multiplícalo por la tarifa y almacena el dato. No hay panel de costos, así que gestiona el seguimiento en tu app.

Cómo usar la API de texto a video de Grok: guía completa

Roobia — Fri, 03 Apr 2026 08:43:20 +0000

TL;DR

La API de texto a video de Grok convierte un prompt de texto en un video. Llama a POST /v1/videos/generations para iniciar la generación y recibe un request_id de inmediato. Luego, haz polling con GET /v1/videos/{request_id} hasta que el estado sea "done". El modelo es grok-imagine-video, con precios desde $0.05 por segundo a 480p. El SDK de Python de xAI automatiza el polling.

Prueba Apidog hoy

Introducción

xAI generó 1.2 mil millones de videos en enero de 2026, el primer mes tras el lanzamiento de la API de texto a video de Grok (28 de enero de 2026). El modelo lideró el ranking de Artificial Analysis de ese mes, demostrando que la infraestructura escala.

Esta guía cubre cómo hacer tu primera solicitud, hacer polling, ajustar parámetros, escribir mejores prompts, usar imágenes de referencia, extender o editar videos y cuándo elegir texto a video.

💡 La API es asíncrona. Tu frontend no puede esperar el video antes de renderizar. Si construyes una UI para generación de video, necesitas mockear el flujo de polling sin gastar créditos. Smart Mock de Apidog permite simular tanto el endpoint de generación como el de polling. Así tu equipo puede avanzar en la UI mientras el backend está en desarrollo. Descarga Apidog gratis para seguir la sección de pruebas más adelante.

¿Qué es la API de texto a video de Grok?

La API de texto a video de Grok es parte del paquete de generación de medios de xAI en https://api.x.ai. Envía un prompt de texto y el modelo grok-imagine-video genera un clip de video desde cero, sin requerir imagen de origen.

Comparte espacio con el endpoint de generación de imágenes síncrono (POST /v1/images/generations, modelo grok-imagine-image, $0.02 por imagen) y endpoints para extender o editar videos.

La diferencia clave con imagen a video: aquí solo envías texto, y el modelo crea la escena, movimiento y estilo desde tu descripción. Si tienes una imagen de origen y quieres animarla, consulta la guía de la API de imagen a video de Grok.

Cómo funciona la generación de texto a video (patrón asíncrono)

La mayoría de APIs esperan la respuesta antes de continuar. Para video, la generación puede tardar de segundos a minutos, así que Grok usa un flujo asíncrono:

Envía un POST con tu prompt.
Recibes un request_id (en menos de 1 segundo).
El video se genera en los servidores de xAI.
Haz polling con GET usando ese request_id repetidamente.
Cuando el estado sea "done", la respuesta trae la URL del video.

Este patrón mantiene conexiones HTTP cortas y permite verificar progreso a tu ritmo. Tu frontend debe manejar el estado intermedio y mostrar un loading hasta que llegue la URL.

Requisitos previos

Antes de programar:

Cuenta xAI: Regístrate en console.x.ai. Agrega facturación para habilitar la generación.
Clave API: En la consola, ve a Claves API y crea una. Guárdala de forma segura. Úsala como token Bearer en el header de cada request.

export XAI_API_KEY="your_api_key_here"

Opcional: instala el SDK de Python de xAI para integración rápida:

pip install xai-sdk

Tu primera solicitud de texto a video

El endpoint es POST https://api.x.ai/v1/videos/generations. Solo necesitas los campos model y prompt.

Usando curl

curl -X POST https://api.x.ai/v1/videos/generations \
  -H "Authorization: Bearer $XAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "grok-imagine-video",
    "prompt": "A golden retriever running through autumn leaves in slow motion, cinematic lighting"
  }'

Respuesta inmediata:

{
  "request_id": "d97415a1-5796-b7ec-379f-4e6819e08fdf"
}

Ese UUID sirve para consultar el video cuando esté listo.

Usando Python y requests

import requests
import os

API_KEY = os.environ["XAI_API_KEY"]
BASE_URL = "https://api.x.ai"

headers = {
    "Authorization": f"Bearer {API_KEY}",
    "Content-Type": "application/json"
}

payload = {
    "model": "grok-imagine-video",
    "prompt": "A golden retriever running through autumn leaves in slow motion, cinematic lighting"
}

response = requests.post(
    f"{BASE_URL}/v1/videos/generations",
    headers=headers,
    json=payload
)

data = response.json()
request_id = data["request_id"]
print(f"Generación iniciada. ID de solicitud: {request_id}")

Sondeo para el resultado del video

Con tu request_id, haz polling a GET /v1/videos/{request_id} hasta que el estado sea "done".

Estados posibles:

"processing": generando
"done": completo, URL disponible
"failed": error

Bucle de polling en Python:

import requests
import time
import os

API_KEY = os.environ["XAI_API_KEY"]
BASE_URL = "https://api.x.ai"

headers = {
    "Authorization": f"Bearer {API_KEY}"
}

def poll_video(request_id: str, interval: int = 5, max_attempts: int = 60) -> dict:
    """Sondea hasta que la generación de video esté completa."""
    url = f"{BASE_URL}/v1/videos/{request_id}"

    for attempt in range(max_attempts):
        response = requests.get(url, headers=headers)
        data = response.json()

        status = data.get("status")
        progress = data.get("progress", 0)
        print(f"Intento {attempt + 1}: estado={status}, progreso={progress}%")

        if status == "done":
            return data
        elif status == "failed":
            raise RuntimeError(f"La generación de video falló: {data}")

        time.sleep(interval)

    raise TimeoutError(f"Video no listo después de {max_attempts} intentos")


# Flujo de trabajo completo: generar y luego sondear
def generate_video(prompt: str) -> str:
    """Genera un video y devuelve su URL."""
    response = requests.post(
        f"{BASE_URL}/v1/videos/generations",
        headers={**headers, "Content-Type": "application/json"},
        json={"model": "grok-imagine-video", "prompt": prompt}
    )
    request_id = response.json()["request_id"]
    print(f"ID de solicitud: {request_id}")

    result = poll_video(request_id)
    video_url = result["video"]["url"]
    print(f"Video listo: {video_url}")
    return video_url


video_url = generate_video(
    "A timelapse of a city skyline at sunset transitioning to night, aerial view"
)

Respuesta de polling cuando está listo:

{
  "status": "done",
  "video": {
    "url": "https://vidgen.x.ai/....mp4",
    "duration": 8,
    "respect_moderation": true
  },
  "progress": 100,
  "usage": {
    "cost_in_usd_ticks": 500000000
  }
}

Usando el SDK de Python de xAI

El SDK gestiona el polling automáticamente. El método client.video.generate() espera hasta que el video esté listo.

from xai_sdk import Client
import os

client = Client(api_key=os.environ["XAI_API_KEY"])

result = client.video.generate(
    model="grok-imagine-video",
    prompt="A golden retriever running through autumn leaves in slow motion",
    duration=8,
    resolution="720p",
    aspect_ratio="16:9"
)

print(f"Video URL: {result.video.url}")
print(f"Duration: {result.video.duration}s")

El SDK es la vía más rápida para prototipos funcionales. Usa requests manuales solo si necesitas controlar lógica de reintentos o intervalos personalizados.

Escribiendo prompts efectivos para video

El prompt es la clave para resultados óptimos. Sé específico y estructurado.

Descripción de la escena

Incluye sujeto y entorno:

"Una taza de café de cerámica blanca sobre una mesa de madera junto a una ventana empapada por la lluvia"

Movimiento

Indica qué se mueve y cómo:

"La cámara orbita lentamente la taza mientras el vapor se eleva"

Estilo de cámara

Usa términos de cine:

"primer plano", "plano de seguimiento", "vista de dron aérea", "cámara en mano", "dolly zoom"

Iluminación y ambiente

Ejemplos útiles:

"hora dorada", "nublado", "iluminado con neones", "atmósfera melancólica"

Referencias de estilo

Nombra estilos visuales:

"cinemático", "documental", "anime", "stop-motion", "hyperlapse"

Estructura recomendada de prompt

Empieza con el sujeto, añade movimiento, describe la cámara, termina con el estilo y el ambiente:

A lone astronaut floats past the International Space Station,
tether drifting behind them. The camera tracks slowly
alongside, showing Earth below. Cinematic, IMAX quality,
warm sunrise light reflecting off the visor.

Controlando resolución, duración y relación de aspecto

El endpoint acepta parámetros opcionales para controlar salida, duración y calidad.

Duración

"duration": 10

Rango: 1–15 segundos. Default: 6s. Más segundos = mayor costo.

Resolución

"resolution": "720p"

Opciones: "480p" (default), "720p". Usa 480p para pruebas y 720p para producción.

Relación de aspecto

"aspect_ratio": "9:16"

Relaciones válidas:

Relación	Uso recomendado
`16:9`	Escritorio, YouTube (default)
`9:16`	TikTok, Instagram Reels, móvil
`1:1`	Instagram feed, tarjetas sociales
`4:3`	Video clásico, presentaciones
`3:4`	Contenido móvil vertical
`3:2`	Foto estándar
`2:3`	Fotografía vertical

Ejemplo completo

curl -X POST https://api.x.ai/v1/videos/generations \
  -H "Authorization: Bearer $XAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "grok-imagine-video",
    "prompt": "A coastal town at dawn, waves breaking gently on a rocky shore",
    "duration": 10,
    "resolution": "720p",
    "aspect_ratio": "16:9"
  }'

Usando imágenes de referencia para guiar el estilo

El parámetro reference_images acepta hasta 7 URLs de imágenes. No se usan como sujeto, sino para guiar el estilo visual del video.

{
  "model": "grok-imagine-video",
  "prompt": "A coastal town at dawn, waves breaking gently on a rocky shore",
  "reference_images": [
    {"url": "https://example.com/my-style-reference.jpg"},
    {"url": "https://example.com/color-palette-reference.jpg"}
  ]
}

Usa imágenes de referencia con estética coherente para influir fuertemente en el resultado. No es lo mismo que imagen a video: aquí el prompt sigue dirigiendo la escena.

Extendiendo y editando videos generados

xAI ofrece dos endpoints extra:

Extender un video

POST /v1/videos/extensions agrega más duración a un video ya generado. Envía el request_id original y un nuevo prompt para continuar la animación.

Editar un video

POST /v1/videos/edits modifica un video existente según una instrucción de texto: cambia el estilo, efectos o la escena.

Ambos endpoints usan el mismo patrón asíncrono: devuelven un request_id y haces polling con GET /v1/videos/{request_id}.

Leyendo el costo en la respuesta de la API

El campo usage en la respuesta incluye el costo en ticks:

"usage": {
  "cost_in_usd_ticks": 500000000
}

Divide entre 10,000,000 para convertir a dólares:

cost_in_usd = result["usage"]["cost_in_usd_ticks"] / 10_000_000
print(f"Costo: ${cost_in_usd:.4f}")
# Ejemplo de salida: Costo: $0.0500

Referencia de precios

Resolución	Precio por segundo	10s de video
480p	$0.05	$0.50
720p	$0.07	$0.70

Controla tus costos leyendo el campo cost_in_usd_ticks de cada respuesta.

Cómo probar tu API de video de Grok con Apidog

El polling asíncrono requiere que tu frontend maneje tres estados: cargando, éxito y error. Simular este flujo con la API real es costoso y lento. Smart Mock de Apidog lo resuelve simulando ambos endpoints.

Caso de uso 1: Smart Mock para desarrollo frontend

Con Smart Mock de Apidog:

Simula POST /v1/videos/generations: Define el esquema de respuesta con un campo request_id tipo string. Apidog genera un UUID falso automáticamente.

Ejemplo de respuesta mock:

  {
    "request_id": "d97415a1-5796-b7ec-379f-4e6819e08fdf"
  }

Simula GET /v1/videos/{request_id}: Define el esquema completo con status, video.url, video.duration, progress y usage.cost_in_usd_ticks. Configura una respuesta mock personalizada con "status": "done" y una URL de MP4 genérica.

Ejemplo de respuesta mock:

  {
    "status": "done",
    "video": {
      "url": "https://vidgen.x.ai/mock-video-12345.mp4",
      "duration": 8,
      "respect_moderation": true
    },
    "progress": 100,
    "usage": {
      "cost_in_usd_ticks": 400000000
    }
  }

Los desarrolladores frontend pueden construir y probar toda la UI del reproductor de video contra este servidor mock. Pueden simular estados de carga, éxito y error modificando el mock. No se gastan créditos reales de la API.

Caso de uso 2: Escenarios de prueba para el bucle de polling

Con los Escenarios de Prueba de Apidog automatiza la validación:

Paso 1: Añade la solicitud POST /v1/videos/generations. Usa una Variable de Extracción para capturar el request_id con JSONPath ($.request_id).

Paso 2: Añade el GET /v1/videos/{{videoRequestId}} en un bucle For, con condición de salida: response.body.status == "done". Añade un delay de 5s entre iteraciones.

Paso 3: Agrega una aserción para que $.video.url no esté vacío en la última respuesta.

Esto asegura una cobertura repetible del flujo asíncrono y ayuda a detectar regresiones en tu lógica de polling.

Texto a video vs imagen a video: ¿cuándo usar cada uno?

Ambos usan grok-imagine-video, pero tienen usos distintos:

Texto a video:

Genera contenido original desde un prompt/concepto.
El modelo tiene control creativo total.
Útil para herramientas donde el usuario solo escribe un prompt.
No tienes una imagen fuente.

Imagen a video:

Tienes una imagen/ilustración/foto de producto a animar.
Necesitas preservar detalles visuales exactos.
Quieres animaciones consistentes desde varias imágenes.

Texto a video crea la escena desde cero; imagen a video anima una imagen existente. Para una guía completa de imagen a video, revisa la guía de la API de imagen a video de Grok.

En productos que soportan ambos modos, decide en tiempo de ejecución: si el usuario sube una imagen, usa /v1/images/generations; si solo escribe texto, usa /v1/videos/generations.

Errores comunes y cómo solucionarlos

401 No Autorizado: Falta la clave API, está caducada o mal formateada. Verifica el header Authorization: Bearer YOUR_XAI_API_KEY y que la clave esté activa.
429 Too Many Requests: Excediste el rate limit (60 req/min, 1 req/seg). Espacia tus llamadas, especialmente en polling (mínimo 5s entre requests).
status: "failed" en polling: El prompt fue rechazado por moderación. El campo respect_moderation será true. Revisa y ajusta el prompt.
La URL del video arroja 404: Las URLs caducan. Descarga el video apenas recibas la URL.
Video vacío o congelado: Prompts vagos o sin instrucciones de movimiento. Sé explícito sobre qué se mueve y cómo.
Polling lento: 720p y duraciones largas tardan más. Usa 480p y clips cortos para desarrollo y prototipado.

Conclusión

La API de texto a video de Grok es directa: envías un prompt, recibes un request_id, haces polling y descargas tu MP4. Domina el patrón asíncrono y el resto (duración, resolución, relación de aspecto, imágenes de referencia) es parametrizable.

Para producción, monitorea el costo leyendo cost_in_usd_ticks tras cada generación. Simula endpoints en Apidog para que el frontend avance sin bloqueos. Usa Escenarios de Prueba para mantener fiable tu lógica de polling.

Descarga Apidog gratis para configurar mocks y escenarios de prueba para la API de video de Grok.

Preguntas Frecuentes

¿Qué nombre de modelo uso para la generación de texto a video?

Usa grok-imagine-video como valor de model en tu POST a /v1/videos/generations.

¿Cuánto tarda la generación de video?

Depende de duración y resolución. 480p corto: <30s. 720p largo: varios minutos. Haz polling cada 5-10s.

¿Puedo generar videos de más de 15 segundos?

No en una sola solicitud. duration máximo: 15s. Para videos más largos, encadena clips y usa POST /v1/videos/extensions.

¿Cómo descargo el video generado?

Usa la URL result.video.url del polling. Descarga el MP4 de inmediato; la URL caduca.

¿Qué sucede si mi prompt viola la moderación de contenido?

El estado será "failed". respect_moderation indicará si hubo moderación. Ajusta el prompt.

¿Hay un nivel gratuito para la API de video?

No hay free tier específico para video. Consulta console.x.ai para créditos de bienvenida.

¿En qué se diferencian las reference_images de una imagen de origen?

reference_images guían el estilo visual del video generado desde texto. Una imagen de origen en imagen a video se convierte en el primer fotograma real.

¿Cómo pruebo el bucle de polling sin gastar créditos?

Usa Smart Mock de Apidog para simular los endpoints de generación y polling. Define los esquemas y estados mock para cubrir todos los casos en tus test.