> ## Documentation Index
> Fetch the complete documentation index at: https://evolink.ai/docs/llms.txt
> Use this file to discover all available pages before exploring further.

# API Kimi (todos los modelos) - Responses: Inicio rápido

> Llama a Kimi con `model` e `input`. Se admiten `kimi-k3.1-pro`, `kimi-k3.1-pro-highspeed` y `kimi-k3`. Al configurar `max_output_tokens`, empieza por 1024 para dejar espacio al razonamiento y a la respuesta.

Consulta la [referencia completa](/es/api-manual/language-series/kimi/responses/responses-reference) para más ejemplos y diferencias entre modelos.

> [!NOTE]
>
> **BaseURL**: La BaseURL predeterminada es `https://direct.evolink.ai`, que ofrece mejor compatibilidad con los modelos de texto y las conexiones de larga duración. `https://api.evolink.ai` es el endpoint principal para los servicios multimodales y sirve como dirección de respaldo para los modelos de texto.

Usa `POST /v1/responses` y selecciona `kimi-k3.1-pro`, `kimi-k3.1-pro-highspeed` o `kimi-k3` con `model`. Solo se requieren `model` e `input`.

> [!WARNING]
>
> **Los nombres de los parámetros difieren de Chat Completions**: usa `input` para la entrada, `max_output_tokens` para el límite de salida y `reasoning.effort` para el esfuerzo de razonamiento.

## Leer el texto de respuesta

El campo `output` puede incluir razonamiento, texto de respuesta y llamadas a herramientas. Recorre los bloques de contenido `output_text` de los elementos `type="message"`; no supongas que el primer elemento contiene la respuesta.

Si el JSON de la respuesta ya se ha analizado en `response`, extrae el texto así:

```python theme={null}
text = "".join(
    part["text"]
    for item in response.get("output", [])
    if item.get("type") == "message"
    for part in item.get("content", [])
    if part.get("type") == "output_text"
)
print(text)
```

> [!NOTE]
>
> **Reserva presupuesto de salida para el razonamiento**: `max_output_tokens` incluye el razonamiento y la respuesta. Si `status="incomplete"` e `incomplete_details.reason="max_output_tokens"`, aumenta el límite. Al agotarse el presupuesto, la respuesta puede contener solo elementos de razonamiento, sin texto de respuesta.

Para llamadas a herramientas, búsqueda web, imágenes de entrada y salida estructurada, consulta la [referencia completa](https://evolink.ai/docs/es/api-manual/language-series/kimi/responses/responses-reference.md).


## OpenAPI

````yaml es/api-manual/language-series/kimi/responses/responses-quickstart.json POST /v1/responses
openapi: 3.1.0
info:
  title: 'API Kimi (todos los modelos) - Responses: Inicio rápido'
  description: >-
    Ejemplos de inicio rápido para llamar a los modelos de texto Kimi mediante
    el protocolo OpenAI Responses. Solo se necesitan `model` y `input` para
    iniciar una conversación; consulta la página «Referencia completa» para
    llamadas a herramientas, búsqueda web, salida estructurada e imágenes de
    entrada, entre otras funciones.
  version: 1.0.0
servers:
  - url: https://direct.evolink.ai
    description: Producción (Recomendado)
  - url: https://api.evolink.ai
    description: URL alternativa
security:
  - bearerAuth: []
paths:
  /v1/responses:
    post:
      tags:
        - Responses
      summary: Llamada rápida a Kimi Responses
      description: >-
        Llama a Kimi con `model` e `input`. Se admiten `kimi-k3.1-pro`,
        `kimi-k3.1-pro-highspeed` y `kimi-k3`. Al configurar
        `max_output_tokens`, empieza por 1024 para dejar espacio al razonamiento
        y a la respuesta.


        Consulta la [referencia
        completa](/es/api-manual/language-series/kimi/responses/responses-reference)
        para más ejemplos y diferencias entre modelos.
      operationId: kimiResponsesQuick
      requestBody:
        required: true
        content:
          application/json:
            schema:
              $ref: '#/components/schemas/ResponsesQuickRequest'
            examples:
              simple:
                summary: Solicitud mínima de Pro
                value:
                  model: kimi-k3.1-pro
                  input: Explica la caché de contexto en una frase.
              highspeed:
                summary: Highspeed con esfuerzo de razonamiento bajo
                value:
                  model: kimi-k3.1-pro-highspeed
                  input: Explica la caché de contexto en una frase.
                  reasoning:
                    effort: low
                  max_output_tokens: 1024
              k3:
                summary: Solicitud mínima de Kimi K3
                value:
                  model: kimi-k3
                  input: Explica la caché de contexto en una frase.
              multi_turn:
                summary: Instrucciones del sistema y conversaciones de varios turnos
                value:
                  model: kimi-k3.1-pro
                  input:
                    - role: developer
                      content: >-
                        Eres un editor técnico riguroso. Responde de forma
                        concisa.
                    - role: user
                      content: ¿Qué es la caché de contexto?
                    - role: assistant
                      content: >-
                        La caché de contexto guarda los prefijos repetidos de
                        las solicitudes para que las solicitudes posteriores que
                        acierten en la caché se procesen más rápido y a menor
                        coste.
                    - role: user
                      content: ¿Para qué casos de uso resulta adecuada?
                  reasoning:
                    effort: low
                  max_output_tokens: 2048
              streaming:
                summary: Salida SSE en streaming
                value:
                  model: kimi-k3.1-pro
                  input: Escribe un poema de cuatro versos sobre una noche de verano.
                  reasoning:
                    effort: low
                  max_output_tokens: 2048
                  stream: true
      responses:
        '200':
          description: >-
            Respuesta creada correctamente; las solicitudes en streaming
            devuelven un flujo de eventos SSE
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ResponsesResponse'
            text/event-stream:
              schema:
                type: string
                description: >-
                  Flujo de eventos SSE en formato Responses que termina con
                  `response.completed`, `response.incomplete` o
                  `response.failed`.
        '400':
          description: 'Solicitud incorrecta: parámetros no válidos'
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ErrorResponse'
        '401':
          description: 'No autorizado: clave API no válida o ausente'
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ErrorResponse'
        '429':
          description: Límite de solicitudes superado o cuota insuficiente
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ErrorResponse'
        '500':
          description: Error del servidor
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ErrorResponse'
components:
  schemas:
    ResponsesQuickRequest:
      type: object
      required:
        - model
        - input
      properties:
        model:
          type: string
          enum:
            - kimi-k3.1-pro
            - kimi-k3.1-pro-highspeed
            - kimi-k3
          default: kimi-k3.1-pro
          description: >-
            Modelo que se va a llamar:


            | ID del modelo | Características |

            |---|---|

            | `kimi-k3.1-pro` | Última generación (recomendado) |

            | `kimi-k3.1-pro-highspeed` | Mismos parámetros que Pro, generación
            más rápida |

            | `kimi-k3` | Generación anterior |


            Los tres modelos tienen una ventana de contexto de 1.048.576 tokens
            y el razonamiento siempre activado.
        input:
          description: >-
            Entrada de esta solicitud. Una cadena equivale a un mensaje user; un
            array proporciona el historial de mensajes en orden.
          oneOf:
            - type: string
            - type: array
              items:
                $ref: '#/components/schemas/InputMessage'
        max_output_tokens:
          type: integer
          minimum: 1
          maximum: 1048576
          default: 131072
          description: >-
            Máximo de tokens generados, incluidos el razonamiento y la respuesta
            final; valor predeterminado 131072, máximo 1048576.
        reasoning:
          type: object
          description: Configuración de razonamiento.
          properties:
            effort:
              type: string
              enum:
                - low
                - high
                - max
              default: max
              description: >-
                Esfuerzo de razonamiento, `max` de forma predeterminada.
                `kimi-k3` solo admite `max`; consulta la referencia completa
                para otros valores compatibles.
        stream:
          type: boolean
          default: false
          description: Si es true, devuelve la respuesta como un flujo SSE.
    ResponsesResponse:
      type: object
      properties:
        id:
          type: string
          description: ID de la respuesta.
          example: resp_6adc72aab1f2eaaebe6b869e
        object:
          type: string
          enum:
            - response
          example: response
        created_at:
          type: integer
          description: Fecha de creación como marca de tiempo Unix en segundos.
          example: 1792832171
        status:
          type: string
          enum:
            - completed
            - incomplete
            - failed
          description: >-
            Estado de la respuesta. `incomplete` suele indicar que se alcanzó el
            límite `max_output_tokens`.
          example: completed
        incomplete_details:
          type:
            - object
            - 'null'
          description: Motivo cuando `status` es `incomplete`.
          properties:
            reason:
              type: string
              enum:
                - max_output_tokens
                - content_filter
        model:
          type: string
          description: Modelo utilizado en esta llamada.
          example: kimi-k3.1-pro
        output:
          type: array
          description: >-
            Array de elementos de salida, normalmente reasoning seguido de
            message.
          items:
            $ref: '#/components/schemas/OutputItem'
        usage:
          $ref: '#/components/schemas/Usage'
    ErrorResponse:
      type: object
      properties:
        error:
          type: object
          properties:
            message:
              type: string
              description: Mensaje que explica la causa del error.
            type:
              type: string
              description: Tipo de error
            code:
              type: string
              description: Código de error
          required:
            - message
      required:
        - error
    InputMessage:
      type: object
      required:
        - role
        - content
      properties:
        role:
          type: string
          enum:
            - user
            - assistant
            - developer
          description: Rol del mensaje. `developer` se trata como instrucciones de sistema.
        content:
          type: string
          description: Contenido del mensaje (texto sin formato).
          example: Explica la caché de contexto en una frase.
    OutputItem:
      type: object
      properties:
        type:
          type: string
          enum:
            - reasoning
            - message
          description: '`reasoning` contiene el razonamiento y `message` la respuesta final.'
          example: message
        id:
          type: string
          example: msg_6adc72aab1f2eaaebe6b869f
        summary:
          type: array
          description: Contenido del razonamiento cuando `type=reasoning`.
          items:
            type: object
            properties:
              type:
                type: string
                enum:
                  - summary_text
              text:
                type: string
        role:
          type: string
          enum:
            - assistant
          description: Se devuelve cuando `type=message`.
        content:
          type: array
          description: Contenido de la respuesta cuando `type=message`.
          items:
            $ref: '#/components/schemas/OutputText'
        status:
          type: string
          enum:
            - completed
          example: completed
    Usage:
      type: object
      properties:
        input_tokens:
          type: integer
          description: Tokens de entrada, incluidos los aciertos de caché.
          example: 24
        input_tokens_details:
          type: object
          properties:
            cached_tokens:
              type: integer
              description: Tokens de entrada servidos desde caché.
              example: 0
        output_tokens:
          type: integer
          description: Tokens de salida, incluidos los de razonamiento.
          example: 96
        output_tokens_details:
          type: object
          properties:
            reasoning_tokens:
              type: integer
              description: Tokens de razonamiento, ya incluidos en output_tokens.
              example: 62
        total_tokens:
          type: integer
          description: Total de tokens de entrada y salida.
          example: 120
    OutputText:
      type: object
      properties:
        type:
          type: string
          enum:
            - output_text
          example: output_text
        text:
          type: string
          example: >-
            La caché de contexto guarda los prefijos repetidos de las
            solicitudes para que las solicitudes posteriores que acierten en la
            caché se procesen más rápido y a menor coste.
  securitySchemes:
    bearerAuth:
      type: http
      scheme: bearer
      description: >-
        ##Todas las API requieren autenticación con Bearer Token##


        **Obtener la API Key:**


        Visita la [página de gestión de API
        Keys](https://evolink.ai/dashboard/keys) para obtener tu API Key


        **Añadir al encabezado de la solicitud:**

        ```

        Authorization: Bearer YOUR_API_KEY

        ```

````

This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.