Blog

Cómo Usar la API de Kimi K2.6

Ashley Innocent

Ashley Innocent

21 April 2026

Cómo Usar la API de Kimi K2.6

Apidog para empresas

Despliegue local

SSO & RBAC

Conforme con SOC 2

Explorar Apidog Enterprise

El anuncio de Kimi K2.6 de Moonshot AI lo posiciona como el nuevo estado del arte de código abierto para codificación, ejecución a largo plazo y enjambres de agentes. La API que lo impulsa es compatible con OpenAI, está alojada en https://api.moonshot.ai/v1 y documentada en la plataforma. Si tienes el SDK de OpenAI instalado, puedes enviar solicitudes reales en unos cinco minutos.

Esta guía te mostrará la autenticación, tu primera solicitud, streaming, llamadas a herramientas, entrada de visión y video, modo de pensamiento y cómo controlar el Enjambre de Agentes con 300 subagentes, y te enseñará cómo probar cada endpoint con Apidog antes de escribir cualquier código de integración.

💡
Ruta rápida: Prueba la API Kimi K2.6 visualmente en Apidog antes de confirmar cualquier código de integración. Una importación, un token Bearer, y estarás haciendo solicitudes reales en streaming con historial completo y validación de esquema. Descarga Apidog gratis.
button

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

curl mínimo:

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."}]
  }'

Eso es todo. El resto de esta guía detalla los aspectos, incluyendo Agent Swarm y el límite de ejecución de 4.000 pasos que Moonshot menciona.

Lo que realmente puedes hacer con esta API

Desde el anuncio de Kimi K2.6, la API habilita todo esto en producción:

Si estás creando herramientas en la misma categoría que el uso de computadora de Claude Code, crear tu propio Claude Code, o Cursor Composer 2, la API K2.6 es un reemplazo directo en la capa del modelo.

Paso 1: Obtener una clave API

  1. Ve a platform.moonshot.ai (o platform.kimi.ai) y regístrate. Funciona con correo electrónico o Google OAuth.
  2. Verifica tu cuenta. Los usuarios internacionales pueden necesitar verificación por SMS.
  3. Agrega la información de facturación. Moonshot suele acreditar las cuentas nuevas con un pequeño saldo gratuito.
  4. Abre API Keys en el panel de control y haz clic en Create Key.
  5. Copia la clave inmediatamente (se muestra una sola vez).
  6. Expórtala:
export KIMI_API_KEY="sk-..."

Agrégala a .zshrc, .bashrc, o a un gestor de secretos para producción. Nunca la comitas.

¿Quieres evitar pagar durante el desarrollo? Cómo Usar Kimi K2.6 Gratis cubre Cloudflare Workers AI, pesos autoalojados y programas de crédito gratuitos.

Paso 2: Elige tu SDK

La API es compatible con OpenAI, por lo que los SDK oficiales de OpenAI funcionan después de cambiar 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 Aplicaciones 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)

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);

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?"}]
  }'

Los tres devuelven la misma estructura de respuesta.

Paso 3: Entender el cuerpo de la solicitud

Los mismos campos que las finalizaciones de chat de OpenAI:

{
  "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" }
}

Dos notas específicas de Moonshot:

Paso 4: Streaming

El streaming es el valor predeterminado adecuado para cualquier interfaz de usuario o generación larga. La salida máxima para tareas de razonamiento puede alcanzar los 98.304 tokens; no querrás esperar todo eso de una vez.

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)

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);
}

El streaming también funciona con llamadas a herramientas; los argumentos llegan como deltas JSON que se concatenan.

Paso 5: Llamadas a herramientas

Moonshot reporta una puntuación Toolathlon del 50.0% y un 96.60% de éxito en la invocación de herramientas en pruebas de socios. El formato es el esquema estándar de llamada a funciones de OpenAI, por lo que se aplican los flujos de trabajo de prueba de API existentes para ingenieros 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"]
            }
        }
    }
]

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),
        })

Segunda llamada (respuesta final)

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

K2.6 es robusto en cadenas de herramientas de múltiples pasos, lo que hace factibles los agentes de codificación de larga duración como Kimi Code. Para una comparación de frameworks, los flujos de trabajo de Claude Code cubren el mismo bucle con un backend diferente.

Paso 6: Entrada de visión

K2.6 obtiene un 79.4% en MMMU-Pro y un 96.9% en V* (con Python). Las imágenes se incorporan al mensaje del usuario utilizando el formato de contenido 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"}}
            ]
        }
    ],
)

Para archivos locales, codifícalos 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}"

Para OCR o lectura de diagramas, combina una instrucción de texto clara con la imagen. Para problemas matemáticos, incluye una herramienta de intérprete de Python; la puntuación MathVision del 93.2% se midió con acceso a Python habilitado.

Paso 7: Entrada de video

Pasa una URL de video o una secuencia de fotogramas:

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"}}
            ]
        }
    ],
)

Los clips cortos (<30s) funcionan en una sola llamada. Los videos más largos se benefician del streaming porque la inferencia fotograma a fotograma produce muchos tokens.

Paso 8: Modo de pensamiento

kimi-k2.6-thinking produce un rastro de razonamiento visible (similar a los modelos de estilo o1 de OpenAI). Moonshot reporta un 96.4% en AIME 2026 y un 90.5% en GPQA-Diamond con el pensamiento habilitado.

Pensando (predeterminado para el modelo de pensamiento):

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

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"}},
)

El rastro de razonamiento se devuelve en un campo reasoning de la respuesta. Puedes ocultarlo a los usuarios finales y mostrar solo la respuesta final, o canalizarlo a un registro de depuración.

Paso 9: Enjambre de Agentes

Agent Swarm es la característica que más vale la pena aprender. Del blog de Kimi K2.6: hasta 300 subagentes, más de 4.000 pasos coordinados, 3 veces la capacidad de K2.5.

Invocalo a través del parámetro de agente de la plataforma:

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
        }
    },
)

Las llamadas de Swarm se ejecutan durante minutos u horas. Tres consejos prácticos:

  1. Usa streaming. Querrás ver el progreso y detener las ejecuciones incorrectas a tiempo.
  2. Limita max_agents. 300 es el techo; de 10 a 30 es más predecible para la mayoría de las tareas.
  3. Establece un presupuesto. Las tareas de swarm largas pueden consumir tokens rápidamente; registra usage en cada respuesta y canalízalo a tus métricas.

El blog de Kimi describe ejecuciones de demostración que modificaron más de 4.000 líneas de código en 13 horas. La arquitectura es lo que hace que esto sea posible; el indicador de la API simplemente lo activa.

Paso 10: Prueba todo con Apidog

Cada sección anterior introduce una forma de cuerpo, un requisito de encabezado o un formato de respuesta diferente. Apidog convierte el ciclo de depuración en un flujo de trabajo visual.

Configuración de Kimi K2.6 en Apidog

  1. Descarga Apidog y crea un proyecto.
  2. Crea un entorno kimi-prod con dos variables: BASE_URL = https://api.moonshot.ai/v1 y KIMI_API_KEY = sk-....
  3. Nueva solicitud API: POST {{BASE_URL}}/chat/completions.
  4. Encabezados: Authorization: Bearer {{KIMI_API_KEY}}, Content-Type: application/json.
  5. Cuerpo (ejemplo de streaming):
{
  "model": "kimi-k2.6",
  "messages": [{ "role": "user", "content": "Hello, Kimi K2.6!" }],
  "stream": true
}
  1. Haz clic en Send. Los tokens se transmiten al panel de respuesta en tiempo real.

Lo que Apidog añade

Para pruebas dentro del editor, Apidog también se ofrece como una extensión de VS Code. Si actualmente estás limitado a Postman, cómo hacer pruebas de API sin Postman te explica la transición.

Manejo de errores que no te dará problemas

Moonshot utiliza códigos de estado HTTP estándar:

Envoltorio de reintentos:

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")

Para desconexiones a mitad del streaming, rastrea los tokens recibidos y reinicia con una instrucción de "continuar desde aquí" si la conexión se cae. El límite de salida de razonamiento de 98.304 tokens significa que los streams largos son normales, no un error.

Control de costes

Moonshot publica sus precios en kimi.com/membership/pricing. Tres consejos de nivel de producción para mantener las facturas predecibles:

Patrón de producción: un solucionador de problemas de GitHub

Aquí tienes un agente que lee un problema de GitHub, localiza el código relevante, propone una solución y ejecuta pruebas, estructurado en torno al bucle de llamada a herramientas 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,
        })

Esto se escala al Enjambre de Agentes agregando la configuración de enjambre extra_body. También funciona bien con la pila multiagente Hermes si deseas puntos de control con intervención humana.

Preguntas frecuentes

Resumen

La API Kimi K2.6 se integra en cualquier cadena de herramientas compatible con OpenAI con dos cambios: la URL base y tu clave API. A partir de ahí, obtienes una ventana de contexto de 262K, Agent Swarm con 300 subagentes, llamadas a herramientas ajustadas para un 96.60% de éxito en la invocación, y los pesos de código abierto como respaldo si alguna vez quieres dejar la API alojada.

Si estás construyendo una nueva integración, usa Apidog para construir y verificar cada endpoint primero. Capturarás errores de esquema, errores de streaming y problemas de autenticación antes de que lleguen a tu base de código. Luego, porta las solicitudes que funcionan a tu servicio de Python o Node con confianza.

Referencias y lectura adicional

Practica el diseño de API en Apidog

Descubre una forma más fácil de construir y usar APIs

Registrarse gratisDescargar