Cómo utilizar la API de Kimi K3

TL;DR Kimi K3 es el nuevo modelo insignia de Moonshot AI, lanzado en julio de 2026 para programación de largo alcance, razonamiento profundo, comprensión multimodal y trabajo de conocimiento de extremo a extremo. Moonshot lo describe como un modelo abierto de clase 3T con 2,8 billones de parámetros, visión nativa y una ventana de contexto de 1 millón de tokens.

Para desarrolladores que quieren acceso rápido sin gestionar cuentas de proveedores por separado, CometAPI lista Kimi K3 como disponible bajo el ID de modelo kimi-k3, usando un endpoint compatible con OpenAI /v1/chat/completions y la URL base https://api.cometapi.com/v1. La página en vivo de CometAPI de Kimi K3 indica un precio de entrada de $2.40 por 1M de tokens y un precio de salida de $12.00 por 1M de tokens, en comparación con las tarifas oficiales del Kimi API de $3.00 por entrada con fallo de caché y $15.00 por salida. Dado que la demanda de Kimi K3 ya ha provocado una limitación temporal de suscripciones en Moonshot, los equipos de producción deberían usar CometAPI no solo por la facilidad de configuración, sino también para comparación de modelos, monitoreo de uso y enrutamiento de respaldo.

Puntos clave

• En producción, preserva los mensajes completos del asistente en flujos de trabajo multivuelta, limita max_completion_tokens, rastrea el uso de tokens y construye rutas de respaldo.
• Kimi K3 es un modelo Mixture-of-Experts de 2,8T parámetros de Moonshot AI con una ventana de contexto de 1M de tokens y comprensión visual nativa.
• El ID del modelo de CometAPI Kimi k3 es kimi-k3; el endpoint principal es POST https://api.cometapi.com/v1/chat/completions.
• K3 siempre razona. Usa reasoning_effort con low, high o max; max es el valor predeterminado en la documentación de Kimi.
• Se recomienda encarecidamente el streaming para tareas largas de programación, investigación y análisis, porque los usuarios pueden ver la salida parcial mientras el modelo sigue trabajando.
• La entrada de visión debe usar arreglos multimodales content. La documentación de Kimi indica que las URL públicas de imágenes no son compatibles en las rutas de visión de Kimi; usa base64 o referencias a archivos subidos.
• Kimi K3 admite salida estructurada, modo JSON, llamadas a herramientas, tool_choice, carga dinámica de herramientas y caché de contexto.

CometAPI es una forma práctica de evaluar Kimi K3 junto con GPT, Claude, Gemini, DeepSeek, Qwen y otros modelos desde una sola capa de API.

Qué es Kimi K3: el modelo insignia de Moonshot AI

Moonshot AI lanzó Kimi K3 el 16 de julio de 2026 como su modelo más capaz hasta la fecha: una arquitectura escasa Mixture-of-Experts (MoE) con ~2,8 billones de parámetros totales (16 de 896 expertos activos por token). Presenta Kimi Delta Attention para hasta 6,3x de decodificación más rápida en contextos de millón de tokens y Attention Residuals para ~25% de mejora en eficiencia de entrenamiento.

Especificaciones clave (fuente: informes oficiales e independientes):

Destaca en programación de largo alcance, tareas agenticas, comprensión visual y trabajo de conocimiento. Benchmarks independientes lo sitúan en posición competitiva (p. ej., 57.1 en Artificial Analysis Intelligence Index, sólido en arenas de programación frontend).

Contexto de últimas noticias de Business Insider: La demanda se disparó tanto tras el lanzamiento que Moonshot pausó temporalmente nuevas suscripciones. Señala el impulso de China en modelos de frontera con pesos abiertos, con Moonshot aspirando a una gran salida a bolsa.

Los pesos completos están programados para el 27 de julio de 2026

La documentación de Kimi K3 de Moonshot dice que los pesos completos del modelo se publicarán para el 27 de julio de 2026. Hasta que esa publicación se complete y maduren las herramientas de despliegue de terceros, la mayoría de los equipos deberían tratar el acceso API alojado como la vía práctica más rápida. Incluso después de que los pesos estén disponibles, servir un modelo MoE de 2,8T parámetros no es lo mismo que ejecutar un modelo abierto pequeño en una sola estación de trabajo. El blog técnico de Moonshot recomienda configuraciones de supernodo con 64 o más aceleradores para el despliegue de K3, lo que significa que una API alojada seguirá siendo la opción predeterminada para muchos equipos de SaaS, agencias, constructores de herramientas internas y equipos de producto de IA.

Rendimiento en benchmarks: datos, fuentes y análisis

Kimi K3 ofrece resultados de frontera, especialmente en programación y áreas agenticas, manteniéndose competitivo en general. Laboratorios independientes como Artificial Analysis confirman las afirmaciones del proveedor con algunas salvedades (p. ej., tasas de alucinación).

Inteligencia general

• Artificial Analysis Intelligence Index v4.1: 57.1 (4.º en general; detrás de Fable 5 ~60, GPT-5.6 Sol ~59; por delante de Claude Opus 4.8 ~55.7).
• GDPval-AA v2 Elo: 1,668 (gran salto desde 1,190 de K2.6; supera a Opus 4.8, detrás de Fable 5).

Fuente: reddit

Benchmarks de programación (proveedor + independientes)

K3 brilla aquí, liderando Frontend Code Arena (1,679 Elo, #1 por delante de Fable 5 y Sol).

Fuente: Kimi

Índice de programación (Artificial Analysis): Fuerte, ~76, competitivo con los líderes.

K3 destaca en trabajo a escala de repositorios, frontend con iteración visual y agentes que usan herramientas. Desarrolladores reportan que está a nivel "Opus 4.8+" para muchas tareas de programación.

¿Qué es la API de Kimi K3?

Kimi K3 en términos simples para desarrolladores

La API de Kimi K3 ofrece a los desarrolladores acceso alojado al modelo K3 de Moonshot AI a través de una interfaz estilo chat-completions. Una solicitud típica envía una lista de mensajes, selecciona model: "kimi-k3" y recibe una respuesta del asistente. Más allá del formato básico de chat, K3 añade funciones relevantes para producción: esfuerzo de razonamiento configurable, contexto largo, entrada visual, streaming, salida JSON y con restricciones de esquema, llamadas a herramientas y caché de contexto.

Kimi K3 no se entiende mejor como un "chatbot general barato". Su propuesta de valor más fuerte es el trabajo pesado. Si tu producto necesita alimentar al modelo con un repositorio grande, un paquete de documentos largo, una exportación de hoja de cálculo densa, múltiples capturas de pantalla, una transcripción de depuración o un plan de herramientas complejo, K3 está diseñado para ese tipo de sesión. Si tu app solo requiere respuestas cortas de FAQ o clasificación sobre entradas pequeñas, un modelo más pequeño podría ser más rentable.

Novedades de la API de K3 y uso

Kimi K3 se basa en modelos anteriores de Kimi con mejoras de nivel frontera:

• 1M de contexto: Procesa repositorios enteros, libros o conversaciones largas sin truncamiento.
• Visión nativa: Analiza imágenes directamente en mensajes (base64 o URLs).
• Razonamiento siempre activo: Esfuerzo máximo por defecto; admite trazas de pensamiento estructuradas (el streaming expone deltas).
• Llamadas a herramientas y agentes: Llamado de funciones al estilo OpenAI para flujos de trabajo complejos.
• Salida estructurada: Modo JSON para un parseo confiable.
• Caché: El caché de prefijos automático reduce drásticamente costos para contextos repetidos (se reportan >90% de aciertos en programación).

Capacidades clave de la API de Kimi K3 en CometAPI

Contexto de 1M tokens para documentos largos y grandes bases de código

CometAPI lista Kimi K3 con una ventana de contexto de 1,000k tokens. Ese tamaño cambia cómo los desarrolladores pueden diseñar flujos de trabajo. En lugar de partir cada documento en muchos fragmentos, puedes probar flujos que mantengan un contexto mucho más grande en una sola solicitud: documentos de arquitectura más extractos de código, requisitos de producto más informes de bugs, artículos de investigación más notas, o historiales largos de soporte al cliente.

Esto no significa que cada solicitud deba usar todo el contexto. Un contexto largo es caro y puede ralentizar la latencia del primer token. Úsalo cuando el modelo necesite visibilidad global, no como sustituto de un buen diseño de recuperación. Un patrón sólido en producción con CometAPI es el enrutamiento híbrido: usa embeddings o búsqueda para recuperar los fragmentos más relevantes, pero mantén K3 disponible para las tareas raras donde un contexto amplio mejora genuinamente la calidad de la respuesta.

Razonamiento siempre activo con reasoning_effort configurable

La documentación de Kimi dice que K3 siempre razona y admite el campo de nivel superior reasoning_effort con low, high y max. Usa menor esfuerzo para tareas ligeras donde la latencia y el costo importan; usa alto o máximo para tareas como depuración, derivaciones matemáticas, revisión de arquitectura, migración de código, síntesis de documentos largos y planificación con múltiples herramientas.

En CometAPI, pasa reasoning_effort en la solicitud de Chat Completions cuando la ruta de Kimi K3 admite parámetros específicos del proveedor. Si tu versión del SDK rechaza el campo de nivel superior, envíalo por extra_body o usa HTTPS en crudo.

Respuestas en streaming para mejor experiencia de usuario

La documentación de streaming de Kimi explica que el streaming envía tokens mediante Server-Sent Events en lugar de esperar a la respuesta completa. Esto es especialmente útil para K3 porque el razonamiento profundo y las salidas largas pueden tardar más que las tareas de chat pequeñas. En una herramienta para desarrolladores, transmite primero un plan y luego el código. En un asistente de investigación, transmite resúmenes de secciones. En una app interna de analítica, transmite observaciones preliminares mientras la respuesta final estructurada aún se está generando.

Entrada de visión para capturas de pantalla, gráficos y videos

Kimi K3 admite comprensión visual. La documentación de visión de Kimi indica que K3 puede entender contenido de imágenes y videos, y que los mensajes de visión deben usar arreglos content con partes image_url o video_url. La misma documentación afirma que las imágenes en formato URL no son compatibles; usa datos base64 o referencias a archivos subidos. Para usuarios de CometAPI, comienza con entrada de imagen base64 en staging porque es simple, portátil y fácil de registrar de forma segura sin depender de un host de imágenes público.

Salida estructurada, modo JSON y llamadas a herramientas

Kimi K3 admite salida estructurada mediante response_format, además de llamadas a herramientas a través de declaraciones de funciones en JSON Schema. Las funciones más nuevas de la API de K3 incluyen tool_choice y carga dinámica de herramientas. Esto es importante para productos con agentes porque el inventario de herramientas puede volverse enorme. En lugar de enviar todas las definiciones de herramientas en cada solicitud, tu app puede exponer primero una pequeña función search_tools, recuperar solo las herramientas relevantes e insertar dinámicamente esas definiciones en la conversación.

La decisión práctica es simple: no elijas solo por la tabla de benchmarks. Usa CometAPI para construir un conjunto de evaluación repetible con tus propios prompts. Incluye al menos de 20 a 50 tareas reales: corrección de bugs, trabajos de extracción, capturas de pantalla, PDFs, preguntas de clientes, trazas de llamadas a herramientas y solicitudes sensibles a costos. Enruta Kimi K3 hacia los trabajos donde su contexto largo, razonamiento y soporte de visión se paguen a sí mismos.

Precios de la API: cuánto cuesta Kimi K3

Precios de Kimi K3 en CometAPI

La página del modelo Kimi K3 de CometAPI lista:

La misma página compara esos números con los precios oficiales de $3.00 de entrada y $15.00 de salida por 1M de tokens, mostrando un descuento del 20% en el listado en vivo de CometAPI. Los precios pueden cambiar, así que verifica la página del modelo en CometAPI antes de publicar copys de precios de alto tráfico o comprometer presupuesto de producción.

Precios oficiales del Kimi API

El blog técnico de Moonshot lista los precios de Kimi API en $0.30 por 1M de tokens de entrada con acierto de caché, $3.00 por 1M de tokens de entrada con fallo de caché y $15.00 por 1M de tokens de salida. También dice que el Kimi API oficial logra una tasa de acierto de caché superior al 90% en cargas de trabajo de programación. Trata ese 90% como una afirmación del proveedor específica de la carga de trabajo, no como una garantía para toda aplicación. Tu tasa de acierto de caché depende de cuán estables sean tus prompts, definiciones de herramientas, prefijos de repositorio e historiales de sesión.

Ejemplos simples de costo en CometAPI

Fórmula: (input_tokens / 1,000,000 * 2.40) + (output_tokens / 1,000,000 * 12.00).

Dos notas importantes. Primero, los tokens de razonamiento suelen facturarse como tokens de salida cuando los generan modelos de razonamiento, así que establece max_completion_tokens con criterio. Segundo, el contexto largo debe ser intencional. Es poderoso enviar 500,000 tokens, pero rara vez es sensato enviar tanto contexto cuando 20,000 tokens de alta señal producirían la misma respuesta.

Cómo usar la API de Kimi K3 en CometAPI

Paso 1: Crea una clave de CometAPI

Crea o inicia sesión en tu cuenta de CometAPI, abre la página de claves de API y crea una clave. Guárdala como una variable de entorno del lado del servidor llamada COMETAPI_KEY. No coloques claves de producción en JavaScript del navegador, apps móviles, repositorios públicos, capturas de pantalla ni logs del lado del cliente.

PowerShell:

$env:COMETAPI_KEY = "your_cometapi_key_here"

macOS o Linux:

export COMETAPI_KEY="your_cometapi_key_here"

Paso 2: Instala el SDK de OpenAI

CometAPI admite SDKs compatibles con OpenAI. En Python, instala el SDK una vez:

python -m pip install --upgrade openai

Paso 3: Realiza tu primera llamada a la API de Kimi K3

Usa la URL base de CometAPI y el ID de modelo kimi-k3:

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ["COMETAPI_KEY"],
    base_url="https://api.cometapi.com/v1",
)

completion = client.chat.completions.create(
    model="kimi-k3",
    messages=[
        {
            "role": "system",
            "content": "You are a precise technical assistant for API developers.",
        },
        {
            "role": "user",
            "content": "Explain when I should use Kimi K3 for a coding agent.",
        },
    ],
    max_completion_tokens=1200,
)

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

La solicitud cURL equivalente:

curl https://api.cometapi.com/v1/chat/completions \
  -H "Authorization: Bearer $COMETAPI_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "kimi-k3",
    "messages": [
      {"role": "system", "content": "You are a precise technical assistant for API developers."},
      {"role": "user", "content": "Explain Kimi K3 in one paragraph."}
    ],
    "max_completion_tokens": 800
  }'

Novedades de la API de K3 y uso

Esfuerzo de razonamiento

Usa reasoning_effort para controlar cuánto presupuesto de razonamiento aplica K3. La documentación de Kimi lista low, high y max, con max como valor por defecto. Para producción, elige según el tipo de tarea:

Ejemplo en Python:

completion = client.chat.completions.create(
    model="kimi-k3",
    reasoning_effort="high",
    messages=[
        {
            "role": "user",
            "content": (
                "Review this migration plan for hidden risks. "
                "Return the top 5 issues and a safer rollout sequence."
            ),
        }
    ],
    max_completion_tokens=2000,
)

message = completion.choices[0].message
print(message.content)

Si tu versión del SDK de OpenAI no acepta reasoning_effort como argumento nominal, pásalo mediante extra_body:

completion = client.chat.completions.create(
    model="kimi-k3",
    messages=[{"role": "user", "content": "Solve this scheduling problem."}],
    extra_body={"reasoning_effort": "high"},
)

Detalle importante de implementación: La documentación sobre pensamiento de Kimi dice que las conversaciones multivuelta con K3 deben preservar el mensaje completo del asistente devuelto por la API, incluidos campos como reasoning_content y tool_calls. Si solo guardas el content visible, puedes degradar la continuidad del razonamiento en sesiones largas.

Respuestas en streaming

Usa streaming cuando la respuesta pueda ser larga, cuando la latencia importe o cuando quieras mostrar progreso en una interfaz de chat.

stream = client.chat.completions.create(
    model="kimi-k3",
    messages=[
        {
            "role": "user",
            "content": "Create a detailed refactor plan for a 200k-line monolith.",
        }
    ],
    stream=True,
    stream_options={"include_usage": True},
    max_completion_tokens=3000,
)

for chunk in stream:
    choice = chunk.choices[0]
    delta = choice.delta

    reasoning = getattr(delta, "reasoning_content", None)
    if reasoning:
        # In most products, store reasoning securely or hide it from end users.
        pass

    if delta.content:
        print(delta.content, end="", flush=True)

    usage = getattr(choice, "usage", None)
    if usage:
        print("\n\nUsage:", usage)

La documentación de streaming de Kimi enfatiza que los flujos SSE terminan con data: [DONE]. En un cliente SSE crudo, no trates el stream como completo hasta que llegue ese marcador.

Entrada de visión

Kimi K3 puede analizar imágenes y videos. La primera prueba más segura en CometAPI es una solicitud con imagen base64. Usa un arreglo content multimodal, no una cadena JSON que contenga un arreglo.

import base64
import mimetypes
from pathlib import Path

image_path = Path("dashboard-screenshot.png")
mime_type = mimetypes.guess_type(image_path.name)[0] or "image/png"
image_b64 = base64.b64encode(image_path.read_bytes()).decode("utf-8")

completion = client.chat.completions.create(
    model="kimi-k3",
    messages=[
        {
            "role": "user",
            "content": [
                {
                    "type": "image_url",
                    "image_url": {
                        "url": f"data:{mime_type};base64,{image_b64}",
                    },
                },
                {
                    "type": "text",
                    "text": (
                        "Review this dashboard screenshot. "
                        "Identify UX issues, missing states, and data-quality risks."
                    ),
                },
            ],
        }
    ],
    max_completion_tokens=1800,
)

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

La documentación de visión de Kimi lista formatos de imagen compatibles como PNG, JPEG, WebP y GIF, y formatos de video compatibles como MP4, MOV, AVI, WebM y otros. También recomiendan mantener la resolución de imagen en 4K o menos y la de video en FHD o menos porque resoluciones más altas pueden costar más tiempo de procesamiento sin mejorar la comprensión del modelo.

Salida estructurada con JSON Schema

Para pipelines de producción, no parsees prosa libre si el siguiente paso espera datos estructurados. Usa response_format con JSON Schema cuando la ruta lo admita.

import json

completion = client.chat.completions.create(
    model="kimi-k3",
    messages=[
        {
            "role": "user",
            "content": (
                "Extract implementation tasks from this request: "
                "Add SSO, migrate billing webhooks, and create admin audit logs."
            ),
        }
    ],
    response_format={
        "type": "json_schema",
        "json_schema": {
            "name": "implementation_tasks",
            "strict": True,
            "schema": {
                "type": "object",
                "properties": {
                    "tasks": {
                        "type": "array",
                        "items": {
                            "type": "object",
                            "properties": {
                                "title": {"type": "string"},
                                "risk": {"type": "string"},
                                "owner": {"type": "string"},
                            },
                            "required": ["title", "risk", "owner"],
                            "additionalProperties": False,
                        },
                    }
                },
                "required": ["tasks"],
                "additionalProperties": False,
            },
        },
    },
)

data = json.loads(completion.choices[0].message.content)
print(data["tasks"])

Llamadas a herramientas y tool_choice

La documentación de buenas prácticas de llamadas a herramientas de K3 recomienda evitar inventarios enormes de herramientas en una sola solicitud. El patrón es: expón primero una función de búsqueda de herramientas, fuerza la recuperación con tool_choice: "required" en el primer turno y luego carga dinámicamente solo las definiciones de herramientas que el modelo necesite.

Ejemplo mínimo estilo clima:

import json

tools = [
    {
        "type": "function",
        "function": {
            "name": "get_order_status",
            "description": "Look up a customer's order status.",
            "parameters": {
                "type": "object",
                "properties": {
                    "order_id": {"type": "string"},
                },
                "required": ["order_id"],
                "additionalProperties": False,
            },
        },
    }
]

messages = [
    {"role": "user", "content": "Where is order A1024?"},
]

first = client.chat.completions.create(
    model="kimi-k3",
    messages=messages,
    tools=tools,
    tool_choice="required",
)

assistant_message = first.choices[0].message
messages.append(assistant_message.model_dump(exclude_none=True))

for call in assistant_message.tool_calls or []:
    args = json.loads(call.function.arguments)
    result = {"order_id": args["order_id"], "status": "Shipped", "eta": "2026-07-24"}
    messages.append(
        {
            "role": "tool",
            "tool_call_id": call.id,
            "content": json.dumps(result),
        }
    )

final = client.chat.completions.create(
    model="kimi-k3",
    messages=messages,
    tools=tools,
)

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

Mejores prácticas de Kimi K3 para equipos de producción

Usa Kimi K3 donde sus fortalezas sean evidentes

Kimi K3 es un candidato fuerte para análisis de repositorios, programación frontend, reproducción de bugs, síntesis de documentos largos, razonamiento con hojas de cálculo, QA asistido por visión y flujos agenticos que necesitan herramientas. Puede ser más modelo del necesario para generación de texto corta, clasificación simple o macros de soporte de bajo riesgo. En CometAPI, crea reglas de enrutamiento de modelos para que K3 reciba el trabajo difícil mientras modelos de menor costo manejan el tráfico rutinario.

Construye respaldos porque el lanzamiento tiene capacidad restringida

El informe de AP sobre la pausa de nuevas suscripciones por parte de Moonshot recuerda que la disponibilidad es parte de la selección de modelos. Construye respaldos a nivel de aplicación. Si Kimi K3 devuelve un error de capacidad del proveedor, enruta a otro modelo de CometAPI con fortalezas similares, reduce el tamaño del contexto o reintenta con retroceso exponencial. Mantén la experiencia de usuario con gracia: muestra progreso, preserva borradores y haz que los fallos sean recuperables.

Preserva el contexto cuidadosamente en sesiones multivuelta

Kimi K3 fue entrenado con historial de pensamiento preservado. El blog técnico de Moonshot advierte que cambiar a K3 a mitad de una sesión o no pasar el mensaje completo del asistente puede reducir la estabilidad. En la práctica, almacena el objeto completo del mensaje del asistente devuelto por la API para herramientas de desarrollo y agentes. No comprimas tool_calls ni campos específicos del proveedor de razonamiento a menos que hayas probado el impacto.

Controla el costo de salida y de razonamiento

Establece siempre max_completion_tokens. La referencia de Kimi API dice que K3 tiene por defecto 131,072 tokens máximos de salida y puede configurarse hasta 1,048,576, sujeto al límite de contexto del modelo. Eso es potente, pero puede sorprender al panel de facturación si tu prompt invita a una respuesta enorme. Para la mayoría de flujos de producto, define límites separados: 800 a 1,500 tokens para resúmenes, 2,000 a 4,000 para análisis detallados y límites mayores solo para generación de formato largo explícita.

Diseña para el caché

El caché de contexto de Kimi funciona mejor cuando el contexto inicial repetido permanece estable. La documentación actual del caché de contexto de Kimi lo describe como automático: no se requiere creación manual de caché, ID de caché ni gestión de TTL. Para agentes de programación, mantén instrucciones de repositorio, definiciones de herramientas y políticas de proyecto en un prefijo consistente. Para QA de documentos, mantén estable el paquete de documentos a lo largo de preguntas relacionadas. Evita reescribir el prompt del sistema en cada turno y coloca el contexto grande fijo cerca del inicio del arreglo messages para que el caché pueda reconocer prefijos repetidos.

Usa visión de forma deliberada

La entrada de visión es valiosa, pero las imágenes y videos consumen tokens según el contenido y la resolución. Usa imágenes cuando agreguen información que el texto no pueda capturar: diseño de UI, gráficos, notas manuscritas, mocks de diseño, capturas de CAD y pantallas de error. Reduce la escala de imágenes demasiado grandes, recorta el espacio en blanco irrelevante y combina la imagen con una pregunta precisa.

Conclusión y recomendaciones

Kimi K3 en CometAPI ofrece capacidades de frontera — contexto masivo, visión y razonamiento — a precios accesibles con fricción mínima de integración. Ya sea que construyas agentes de programación, apps multimodales o servicios de IA escalables, comienza con CometAPI para acceso unificado, ahorros y fiabilidad. Regístrate, experimenta con los quickstarts de arriba y escala con confianza.