DEV Community

Cover image for Cómo Usar la API de Kimi K2.6
Roobia
Roobia

Posted on • Originally published at apidog.com

Cómo Usar la API de Kimi K2.6

El anuncio de Kimi K2.6 de Moonshot AI lo posiciona como el nuevo estándar open-source para codificación, ejecución prolongada y enjambres de agentes. La API es compatible con OpenAI, está alojada en https://api.moonshot.ai/v1 y documentada en la plataforma. Si ya tienes el SDK de OpenAI, puedes enviar solicitudes reales en minutos.

Prueba Apidog hoy

Esta guía cubre autenticación, tu primera solicitud, streaming, llamadas a herramientas, entrada de visión/video, modo de pensamiento, control del Agent Swarm con 300 subagentes y cómo testear cada endpoint con Apidog antes de escribir código de integración.

💡 Ruta rápida: Prueba la API Kimi K2.6 visualmente en Apidog antes de codificar. Solo importa el endpoint, añade tu token Bearer y estarás haciendo solicitudes reales en streaming, con historial completo y validación de esquema.

TL;DR: API Kimi K2.6 en 60 segundos

  • URL Base: https://api.moonshot.ai/v1
  • Endpoint: POST /chat/completions
  • IDs de Modelo: kimi-k2.6, kimi-k2.6-thinking
  • Autenticación: Authorization: Bearer $KIMI_API_KEY
  • Formato: Esquema de chat de OpenAI (mensajes, herramientas, stream, etc.)
  • Contexto: 262.144 tokens de entrada, hasta 98.304 tokens de salida para razonamiento
  • Valores predeterminados: temperatura 1.0, top-p 1.0 (guía oficial de Moonshot)

curl básico:

curl https://api.moonshot.ai/v1/chat/completions \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $KIMI_API_KEY" \
  -d '{
    "model": "kimi-k2.6",
    "messages": [{"role": "user", "content": "Write a Python function that reverses a string."}]
  }'
Enter fullscreen mode Exit fullscreen mode

El resto de la guía detalla temas clave como Agent Swarm y el límite de 4.000 pasos.

Kimi K2.6

Lo que puedes hacer con esta API

Según el anuncio de Kimi K2.6:

  • Agentes de codificación: ejecutan tareas de más de 12 horas (ejemplo: Qwen3.5-0.8B Mac, >4.000 llamadas a herramientas, 15–193 tokens/seg).
  • Gestión autónoma de infraestructura: sesiones de varios días, respuesta automática a incidentes.
  • Fiabilidad a largo plazo: soporte en Rust, Go, Python, Zig.
  • Enjambres de agentes: hasta 300 subagentes, >4.000 pasos coordinados.
  • Desarrollo guiado por diseño: genera aplicaciones full-stack desde una sola instrucción.
  • Visión + herramientas Python: pipelines de MathVision con Python (93,2%).

Si desarrollas productos similares a Claude Code Computer Use, tu propio Claude Code, o Cursor Composer 2, la API K2.6 es un reemplazo directo.

Paso 1: Obtener una clave API

  1. Ve a platform.moonshot.ai o platform.kimi.ai y regístrate (email/Google OAuth).
  2. Verifica tu cuenta (internacionales: posible SMS).
  3. Añade la info de facturación. Suele haber crédito inicial gratuito.
  4. En el panel, abre API Keys y haz clic en Create Key.
  5. Copia la clave inmediatamente (solo se muestra una vez).
  6. Expórtala: 
export KIMI_API_KEY="sk-..."
Enter fullscreen mode Exit fullscreen mode

Agrega la variable a .zshrc, .bashrc o un gestor de secretos. Nunca la subas al repositorio.

¿Quieres evitar costes en desarrollo? Lee Cómo Usar Kimi K2.6 Gratis (Cloudflare Workers AI, pesos open-source, créditos).

Paso 2: Elige tu SDK

La API es compatible con OpenAI, así que puedes usar sus SDK oficiales modificando solo la URL base.

Opción Instalación Mejor para
curl integrado Pruebas rápidas, CI
OpenAI Python pip install openai Servicios Python
OpenAI Node npm install openai Apps JS/TS

Python 

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.getenv("KIMI_API_KEY"),
    base_url="https://api.moonshot.ai/v1",
)

response = client.chat.completions.create(
    model="kimi-k2.6",
    messages=[{"role": "user", "content": "What is the capital of France?"}],
)

print(response.choices[0].message.content)
Enter fullscreen mode Exit fullscreen mode

Node.js 

import OpenAI from "openai";

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

const response = await client.chat.completions.create({
  model: "kimi-k2.6",
  messages: [{ role: "user", content: "What is the capital of France?" }],
});

console.log(response.choices[0].message.content);
Enter fullscreen mode Exit fullscreen mode

curl 

curl https://api.moonshot.ai/v1/chat/completions \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $KIMI_API_KEY" \
  -d '{
    "model": "kimi-k2.6",
    "messages": [{"role": "user", "content": "What is the capital of France?"}]
  }'
Enter fullscreen mode Exit fullscreen mode

Todos devuelven la misma estructura de respuesta.

Paso 3: Estructura del cuerpo de la solicitud

Utiliza los mismos campos que OpenAI Chat Completions:

{
  "model": "kimi-k2.6",
  "messages": [
    { "role": "system", "content": "You are a helpful assistant." },
    { "role": "user", "content": "Your prompt here." }
  ],
  "temperature": 1.0,
  "top_p": 1.0,
  "max_tokens": 8192,
  "stream": false,
  "tools": [],
  "tool_choice": "auto",
  "thinking": { "type": "disabled" }
}
Enter fullscreen mode Exit fullscreen mode

Específico de Moonshot:

  • Valores predeterminados altos. Usar temp=1.0 y top-p=1.0 (no bajes a 0.2 como en OpenAI).
  • thinking: Activa rastreo de razonamiento en kimi-k2.6-thinking. Usa {"type": "disabled"} para respuestas rápidas.

Paso 4: Streaming

El streaming es recomendado para UIs o salidas largas (hasta 98.304 tokens de salida).

Python 

stream = client.chat.completions.create(
    model="kimi-k2.6",
    messages=[{"role": "user", "content": "Write a 500-word essay on MoE models."}],
    stream=True,
)

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

Node.js 

const stream = await client.chat.completions.create({
  model: "kimi-k2.6",
  messages: [{ role: "user", content: "Write a 500-word essay on MoE models." }],
  stream: true,
});

for await (const chunk of stream) {
  const delta = chunk.choices[0]?.delta?.content;
  if (delta) process.stdout.write(delta);
}
Enter fullscreen mode Exit fullscreen mode

El streaming soporta llamadas a herramientas: los argumentos llegan como deltas JSON concatenados.

Paso 5: Llamadas a herramientas

Moonshot reporta 50% Toolathlon y 96.60% éxito en invocación. El formato es idéntico al de OpenAI Function Calling, por lo que puedes aplicar flujos de testing de API de QA.

Definir herramientas 

tools = [
    {
        "type": "function",
        "function": {
            "name": "get_weather",
            "description": "Get the current weather in a location.",
            "parameters": {
                "type": "object",
                "properties": {
                    "location": {"type": "string", "description": "City name"},
                    "unit": {"type": "string", "enum": ["celsius", "fahrenheit"]}
                },
                "required": ["location"]
            }
        }
    }
]
Enter fullscreen mode Exit fullscreen mode

Primera llamada (el modelo decide) 

import json

messages = [{"role": "user", "content": "What's the weather in Tokyo?"}]

resp = client.chat.completions.create(
    model="kimi-k2.6",
    messages=messages,
    tools=tools,
    tool_choice="auto",
)

msg = resp.choices[0].message
messages.append(msg)

if msg.tool_calls:
    for call in msg.tool_calls:
        args = json.loads(call.function.arguments)
        result = fetch_weather(args["location"], args.get("unit", "celsius"))
        messages.append({
            "role": "tool",
            "tool_call_id": call.id,
            "content": json.dumps(result),
        })
Enter fullscreen mode Exit fullscreen mode

Segunda llamada (respuesta final) 

final = client.chat.completions.create(
    model="kimi-k2.6",
    messages=messages,
    tools=tools,
)
print(final.choices[0].message.content)
Enter fullscreen mode Exit fullscreen mode

K2.6 soporta cadenas de herramientas de múltiples pasos, útil para agentes de codificación extensos como Kimi Code. Para comparar frameworks, revisa flujos de trabajo de Claude Code.

Paso 6: Entrada de visión

K2.6 logra 79.4% en MMMU-Pro y 96.9% en V* (con Python). Usa el formato image_url de OpenAI:

response = client.chat.completions.create(
    model="kimi-k2.6",
    messages=[
        {
            "role": "user",
            "content": [
                {"type": "text", "text": "Describe this image in one sentence."},
                {"type": "image_url", "image_url": {"url": "https://example.com/photo.jpg"}}
            ]
        }
    ],
)
Enter fullscreen mode Exit fullscreen mode

Para imágenes locales, encódalas en base64:

import base64
with open("photo.jpg", "rb") as f:
    b64 = base64.b64encode(f.read()).decode("utf-8")

image_url = f"data:image/jpeg;base64,{b64}"
Enter fullscreen mode Exit fullscreen mode

Para OCR, diagramas o problemas matemáticos, combina un prompt claro con la imagen y, si es necesario, habilita la herramienta Python (MathVision: 93,2%).

Paso 7: Entrada de video

Envía una URL de video o secuencia de frames:

response = client.chat.completions.create(
    model="kimi-k2.6",
    messages=[
        {
            "role": "user",
            "content": [
                {"type": "text", "text": "Summarize what happens in this video."},
                {"type": "video_url", "video_url": {"url": "https://example.com/clip.mp4"}}
            ]
        }
    ],
)
Enter fullscreen mode Exit fullscreen mode

Clips cortos (<30s) funcionan en una llamada. En videos largos, usa streaming para manejar la gran cantidad de tokens.

Paso 8: Modo de pensamiento

kimi-k2.6-thinking expone el razonamiento paso a paso (como los modelos OpenAI o1). Moonshot reporta 96.4% en AIME 2026 y 90.5% en GPQA-Diamond.

Pensamiento activado:

response = client.chat.completions.create(
    model="kimi-k2.6-thinking",
    messages=[{"role": "user", "content": "Prove sqrt(2) is irrational."}],
)
Enter fullscreen mode Exit fullscreen mode

Pensamiento desactivado:

response = client.chat.completions.create(
    model="kimi-k2.6-thinking",
    messages=[{"role": "user", "content": "Quick: what's 17 * 23?"}],
    extra_body={"thinking": {"type": "disabled"}},
)
Enter fullscreen mode Exit fullscreen mode

El razonamiento aparece en el campo reasoning de la respuesta. Puedes ocultarlo o mostrarlo en logs.

Paso 9: Enjambre de Agentes

Agent Swarm es la característica más avanzada. Según el blog de Kimi K2.6: hasta 300 subagentes y 4.000 pasos coordinados (x3 frente a K2.5).

Actívalo con el parámetro agent:

response = client.chat.completions.create(
    model="kimi-k2.6",
    messages=[{
        "role": "user",
        "content": "Build a 5-page marketing site for a coffee brand with responsive design and a newsletter signup."
    }],
    extra_body={
        "agent": {
            "type": "swarm",
            "max_agents": 30,
            "max_steps": 4000
        }
    },
)
Enter fullscreen mode Exit fullscreen mode

Consejos prácticos:

  1. Usa streaming para monitorizar progreso y abortar ejecuciones incorrectas.
  2. Ajusta max_agents (10-30 es lo recomendable).
  3. Controla presupuesto: monitorea el campo usage de cada respuesta.

El blog de Kimi reporta ejecuciones de más de 4.000 líneas de código modificadas en 13 horas.

Paso 10: Testea todo con Apidog

Cada variante de cuerpo, header o respuesta puede ser validada visualmente con Apidog.

Apidog Kimi

Configuración de Kimi K2.6 en Apidog

  1. Descarga Apidog y crea un proyecto.
  2. Crea un entorno kimi-prod con:
    • BASE_URL = https://api.moonshot.ai/v1
    • KIMI_API_KEY = sk-...
  3. Nueva solicitud API: POST {{BASE_URL}}/chat/completions
  4. Headers:
    • Authorization: Bearer {{KIMI_API_KEY}}
    • Content-Type: application/json
  5. Cuerpo de ejemplo: 
{
  "model": "kimi-k2.6",
  "messages": [{ "role": "user", "content": "Hello, Kimi K2.6!" }],
  "stream": true
}
Enter fullscreen mode Exit fullscreen mode
  1. Haz clic en Send. Los tokens aparecerán en tiempo real.

¿Qué añade Apidog?

  • Validación de esquema compatible con OpenAI.
  • Historial de solicitudes para debugging y reproducibilidad.
  • Cambio de entorno (dev/staging/prod) con un clic.
  • Colaboración en equipo mediante exportación de proyectos (equipos grandes).
  • Mock servers para pruebas offline o caídas de Moonshot.
  • Soporte de streaming SSE para el formato de Kimi (muchas otras herramientas fallan en esto).

Existe también como extensión de VS Code. ¿Migrando desde Postman? Te explicamos la transición.

Manejo de errores

Moonshot usa HTTP estándar:

  • 400: cuerpo mal formado o modelo incorrecto.
  • 401: fallo de autenticación.
  • 429: límite de cuota o rate limit.
  • 500: error servidor (reintenta con backoff).
  • 529: sobrecarga (reintenta tras segundos).

Ejemplo de reintentos en Python:

import time
from openai import OpenAI, RateLimitError, APIError

def call_kimi(messages, max_retries=5):
    for attempt in range(max_retries):
        try:
            return client.chat.completions.create(
                model="kimi-k2.6",
                messages=messages,
            )
        except RateLimitError:
            time.sleep(2 ** attempt)
        except APIError as e:
            if e.status_code >= 500 and attempt < max_retries - 1:
                time.sleep(2 ** attempt)
            else:
                raise
    raise RuntimeError("Kimi K2.6 failed after retries")
Enter fullscreen mode Exit fullscreen mode

En streams largos, si la conexión cae, rastrea los tokens y reintenta con un mensaje de "continúa desde aquí".

Control de costes

Consulta precios actualizados.

Recomendaciones:

  • Limita max_tokens al mínimo necesario (ej: 2048 para chat).
  • Caché de prompts del sistema: pon instrucciones estáticas primero.
  • Monitorea el campo usage de cada respuesta (tokens usados), y canalízalo a tu sistema de métricas/alertas.

Patrón de producción: Solucionador de problemas de GitHub

Ejemplo de agente que itera sobre un issue, localiza código, propone solución y ejecuta tests, usando el loop de tool-calling de Kimi K2.6:

from openai import OpenAI
import os, json

client = OpenAI(
    api_key=os.getenv("KIMI_API_KEY"),
    base_url="https://api.moonshot.ai/v1",
)

tools = [
    {"type": "function", "function": {
        "name": "read_file",
        "description": "Read a file in the repo.",
        "parameters": {
            "type": "object",
            "properties": {"path": {"type": "string"}},
            "required": ["path"]
        }
    }},
    {"type": "function", "function": {
        "name": "search_code",
        "description": "Ripgrep the codebase for a pattern.",
        "parameters": {
            "type": "object",
            "properties": {"query": {"type": "string"}},
            "required": ["query"]
        }
    }},
    {"type": "function", "function": {
        "name": "run_tests",
        "description": "Run the project test suite.",
        "parameters": {"type": "object", "properties": {}}
    }},
]

def tool_dispatch(name, args):
    if name == "read_file":
        with open(args["path"]) as f:
            return f.read()
    if name == "search_code":
        return run_ripgrep(args["query"])
    if name == "run_tests":
        return run_pytest()
    raise ValueError(f"Unknown tool: {name}")

messages = [
    {"role": "system", "content": "You are a senior engineer. Fix the described bug."},
    {"role": "user", "content": "Issue: login form submits twice on slow networks."}
]

while True:
    resp = client.chat.completions.create(
        model="kimi-k2.6",
        messages=messages,
        tools=tools,
    )
    msg = resp.choices[0].message
    messages.append(msg)

    if not msg.tool_calls:
        print(msg.content)
        break

    for call in msg.tool_calls:
        result = tool_dispatch(call.function.name, json.loads(call.function.arguments))
        messages.append({
            "role": "tool",
            "tool_call_id": call.id,
            "content": result,
        })
Enter fullscreen mode Exit fullscreen mode

Para escalar a Agent Swarm, agrega la configuración de swarm en extra_body. Funciona también con la pila multiagente Hermes si quieres intervención humana.

Preguntas frecuentes

  • ¿Necesito un SDK específico de Moonshot?

    No. Los SDK de OpenAI para Python/Node funcionan cambiando base_url.

  • ¿La API tiene límite de tasa?

    Sí, ajustado por cuenta y uso. Verifica en el panel.

  • ¿Funciona con LangChain, LlamaIndex, Vercel AI SDK?

    Sí, todo lo compatible con OpenAI y URL base personalizada.

  • ¿Soporta modo JSON?

    Sí. Usa response_format: {"type": "json_object"} o {"type": "json_schema", ...} para esquemas estrictos.

  • ¿Tamaño de contexto?

    262.144 tokens de entrada, 98.304 de salida (ver blog oficial).

  • ¿Se puede hacer fine-tune vía API?

    No aún. Solo con los pesos open-source en hardware propio.

  • ¿Diferencia entre kimi-k2.6 y kimi-k2.6-thinking?

    kimi-k2.6: agente rápido.

    kimi-k2.6-thinking: expone razonamiento, ajustado para lógica y matemáticas.

  • ¿Hay capa gratuita?

    Sí, consulta la guía de acceso gratuito.

Resumen

La API Kimi K2.6 se integra en cualquier flujo OpenAI cambiando dos cosas: URL base y clave API. Obtienes ventana de contexto de 262K, Agent Swarm, llamadas a herramientas con alta tasa de éxito y pesos open-source como respaldo.

Para nuevas integraciones, usa Apidog para construir y validar endpoints antes de portar el flujo a tu código Python/Node. Así detectas fallos de esquema, de autenticación y de streaming antes de que lleguen a producción.

Referencias y lectura adicional

Top comments (0)