> ## 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.

# Kimi API (alle Modelle) - Responses: Schnellstart

> Kimi mit `model` und `input` aufrufen. Unterstützt werden `kimi-k3.1-pro`, `kimi-k3.1-pro-highspeed` und `kimi-k3`. Für `max_output_tokens` mit 1024 beginnen, um Platz für Reasoning und Antwort zu lassen.

Weitere Beispiele und Modellunterschiede stehen in der [vollständigen Referenz](/de/api-manual/language-series/kimi/responses/responses-reference).

> [!NOTE]
>
> **BaseURL**: Die Standard-BaseURL ist `https://direct.evolink.ai`, die Textmodelle und langlebige Verbindungen besser unterstützt. `https://api.evolink.ai` ist der primäre Endpunkt für multimodale Dienste und dient als Ausweichadresse für Textmodelle.

Verwenden Sie `POST /v1/responses` und wählen Sie mit `model` zwischen `kimi-k3.1-pro`, `kimi-k3.1-pro-highspeed` und `kimi-k3`. Nur `model` und `input` sind erforderlich.

> [!WARNING]
>
> **Die Parameternamen unterscheiden sich von Chat Completions**: Eingaben verwenden `input`, das Ausgabelimit `max_output_tokens` und der Reasoning-Aufwand `reasoning.effort`.

## Antworttext auslesen

Die Antwort `output` kann Reasoning, Antworttext und Tool-Aufrufe enthalten. Durchlaufen Sie die `output_text`-Inhaltsblöcke der Elemente mit `type="message"`; gehen Sie nicht davon aus, dass das erste Element die Antwort enthält.

Wenn das Antwort-JSON bereits als `response` eingelesen wurde, lässt sich der Text so extrahieren:

```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]
>
> **Ausgabebudget für Reasoning einplanen**: `max_output_tokens` umfasst Reasoning und Antwort. Bei `status="incomplete"` und `incomplete_details.reason="max_output_tokens"` erhöhen Sie das Limit. Bei ausgeschöpftem Budget kann die Antwort nur Reasoning-Elemente ohne Antworttext enthalten.

Tool-Aufrufe, Websuche, Bildeingaben und strukturierte Ausgaben sind in der [vollständigen Referenz](https://evolink.ai/docs/de/api-manual/language-series/kimi/responses/responses-reference.md) beschrieben.


## OpenAPI

````yaml de/api-manual/language-series/kimi/responses/responses-quickstart.json POST /v1/responses
openapi: 3.1.0
info:
  title: 'Kimi API (alle Modelle) - Responses: Schnellstart'
  description: >-
    Schnellstart-Beispiele für Kimi-Textmodelle über das Protokoll OpenAI
    Responses. Für ein Gespräch genügen `model` und `input`; Tool-Aufrufe,
    Websuche, strukturierte Ausgaben, Bildeingaben und weitere Funktionen sind
    auf der Seite „Vollständige Referenz“ beschrieben.
  version: 1.0.0
servers:
  - url: https://direct.evolink.ai
    description: Produktion (Empfohlen)
  - url: https://api.evolink.ai
    description: Alternative URL
security:
  - bearerAuth: []
paths:
  /v1/responses:
    post:
      tags:
        - Responses
      summary: 'Kimi Responses: schneller Aufruf'
      description: >-
        Kimi mit `model` und `input` aufrufen. Unterstützt werden
        `kimi-k3.1-pro`, `kimi-k3.1-pro-highspeed` und `kimi-k3`. Für
        `max_output_tokens` mit 1024 beginnen, um Platz für Reasoning und
        Antwort zu lassen.


        Weitere Beispiele und Modellunterschiede stehen in der [vollständigen
        Referenz](/de/api-manual/language-series/kimi/responses/responses-reference).
      operationId: kimiResponsesQuick
      requestBody:
        required: true
        content:
          application/json:
            schema:
              $ref: '#/components/schemas/ResponsesQuickRequest'
            examples:
              simple:
                summary: Minimale Pro-Anfrage
                value:
                  model: kimi-k3.1-pro
                  input: Erkläre Kontext-Caching in einem Satz.
              highspeed:
                summary: Highspeed mit geringem Reasoning-Aufwand
                value:
                  model: kimi-k3.1-pro-highspeed
                  input: Erkläre Kontext-Caching in einem Satz.
                  reasoning:
                    effort: low
                  max_output_tokens: 1024
              k3:
                summary: Minimale Kimi-K3-Anfrage
                value:
                  model: kimi-k3
                  input: Erkläre Kontext-Caching in einem Satz.
              multi_turn:
                summary: System-Prompts und mehrstufige Gespräche
                value:
                  model: kimi-k3.1-pro
                  input:
                    - role: developer
                      content: >-
                        Du bist ein sorgfältiger technischer Redakteur. Antworte
                        knapp.
                    - role: user
                      content: Was ist Kontext-Caching?
                    - role: assistant
                      content: >-
                        Kontext-Caching speichert wiederkehrende Präfixe von
                        Anfragen, damit spätere Cache-Treffer schneller und
                        kostengünstiger verarbeitet werden können.
                    - role: user
                      content: Für welche Anwendungsfälle eignet es sich?
                  reasoning:
                    effort: low
                  max_output_tokens: 2048
              streaming:
                summary: SSE-Streaming-Ausgabe
                value:
                  model: kimi-k3.1-pro
                  input: Schreibe ein vierzeiliges Gedicht über eine Sommernacht.
                  reasoning:
                    effort: low
                  max_output_tokens: 2048
                  stream: true
      responses:
        '200':
          description: >-
            Antwort erfolgreich erstellt; Streaming-Anfragen liefern einen
            SSE-Ereignisstrom
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ResponsesResponse'
            text/event-stream:
              schema:
                type: string
                description: >-
                  SSE-Ereignisstrom im Responses-Format, der mit
                  `response.completed`, `response.incomplete` oder
                  `response.failed` endet.
        '400':
          description: Ungültige Anfrage – ungültige Parameter
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ErrorResponse'
        '401':
          description: Nicht autorisiert – API-Schlüssel ungültig oder fehlt
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ErrorResponse'
        '429':
          description: Ratenlimit überschritten oder Kontingent nicht ausreichend
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ErrorResponse'
        '500':
          description: Serverfehler
          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: >-
            Aufzurufendes Modell:


            | Modell-ID | Einordnung |

            |---|---|

            | `kimi-k3.1-pro` | Neueste Modellgeneration (empfohlen) |

            | `kimi-k3.1-pro-highspeed` | Gleiche Parameter wie Pro, schnellere
            Generierung |

            | `kimi-k3` | Vorherige Modellgeneration |


            Alle drei Modelle haben ein Kontextfenster von 1.048.576 Tokens und
            immer aktives Reasoning.
        input:
          description: >-
            Eingabe dieser Anfrage. Ein String entspricht einer user-Nachricht;
            ein Array enthält historische Nachrichten in Reihenfolge.
          oneOf:
            - type: string
            - type: array
              items:
                $ref: '#/components/schemas/InputMessage'
        max_output_tokens:
          type: integer
          minimum: 1
          maximum: 1048576
          default: 131072
          description: >-
            Maximale generierte Tokens einschließlich Reasoning und endgültiger
            Antwort; Standard 131072, Maximum 1048576.
        reasoning:
          type: object
          description: Konfiguration der Schlussfolgerungen.
          properties:
            effort:
              type: string
              enum:
                - low
                - high
                - max
              default: max
              description: >-
                Reasoning-Aufwand, Standard `max`. `kimi-k3` unterstützt nur
                `max`; weitere kompatible Werte stehen in der vollständigen
                Referenz.
        stream:
          type: boolean
          default: false
          description: Bei true wird die Antwort als SSE-Stream zurückgegeben.
    ResponsesResponse:
      type: object
      properties:
        id:
          type: string
          description: Antwort-ID.
          example: resp_6adc72aab1f2eaaebe6b869e
        object:
          type: string
          enum:
            - response
          example: response
        created_at:
          type: integer
          description: Erstellungszeit als Unix-Zeitstempel in Sekunden.
          example: 1792832171
        status:
          type: string
          enum:
            - completed
            - incomplete
            - failed
          description: >-
            Antwortstatus. `incomplete` bedeutet meist, dass das Limit
            `max_output_tokens` erreicht wurde.
          example: completed
        incomplete_details:
          type:
            - object
            - 'null'
          description: Grund bei `status` gleich `incomplete`.
          properties:
            reason:
              type: string
              enum:
                - max_output_tokens
                - content_filter
        model:
          type: string
          description: Für diesen Aufruf verwendetes Modell.
          example: kimi-k3.1-pro
        output:
          type: array
          description: Ausgabe-Elemente, üblicherweise zuerst reasoning, dann message.
          items:
            $ref: '#/components/schemas/OutputItem'
        usage:
          $ref: '#/components/schemas/Usage'
    ErrorResponse:
      type: object
      properties:
        error:
          type: object
          properties:
            message:
              type: string
              description: Fehlermeldung mit Ursache.
            type:
              type: string
              description: Fehlertyp
            code:
              type: string
              description: Fehlercode
          required:
            - message
      required:
        - error
    InputMessage:
      type: object
      required:
        - role
        - content
      properties:
        role:
          type: string
          enum:
            - user
            - assistant
            - developer
          description: Nachrichtenrolle. `developer` wird als Systemanweisung behandelt.
        content:
          type: string
          description: Nachrichteninhalt (Klartext).
          example: Erkläre Kontext-Caching in einem Satz.
    OutputItem:
      type: object
      properties:
        type:
          type: string
          enum:
            - reasoning
            - message
          description: >-
            `reasoning` enthält den Reasoning-Inhalt, `message` die endgültige
            Antwort.
          example: message
        id:
          type: string
          example: msg_6adc72aab1f2eaaebe6b869f
        summary:
          type: array
          description: Reasoning-Inhalt bei `type=reasoning`.
          items:
            type: object
            properties:
              type:
                type: string
                enum:
                  - summary_text
              text:
                type: string
        role:
          type: string
          enum:
            - assistant
          description: Wird bei `type=message` zurückgegeben.
        content:
          type: array
          description: Antwortinhalt bei `type=message`.
          items:
            $ref: '#/components/schemas/OutputText'
        status:
          type: string
          enum:
            - completed
          example: completed
    Usage:
      type: object
      properties:
        input_tokens:
          type: integer
          description: Eingabe-Tokens einschließlich Cache-Treffern.
          example: 24
        input_tokens_details:
          type: object
          properties:
            cached_tokens:
              type: integer
              description: Aus dem Cache gelieferte Eingabe-Token.
              example: 0
        output_tokens:
          type: integer
          description: Ausgabe-Tokens einschließlich Reasoning-Tokens.
          example: 96
        output_tokens_details:
          type: object
          properties:
            reasoning_tokens:
              type: integer
              description: Reasoning-Tokens, bereits in output_tokens enthalten.
              example: 62
        total_tokens:
          type: integer
          description: Gesamtzahl der Eingabe- und Ausgabe-Token.
          example: 120
    OutputText:
      type: object
      properties:
        type:
          type: string
          enum:
            - output_text
          example: output_text
        text:
          type: string
          example: >-
            Kontext-Caching speichert wiederkehrende Präfixe von Anfragen, damit
            spätere Cache-Treffer schneller und kostengünstiger verarbeitet
            werden können.
  securitySchemes:
    bearerAuth:
      type: http
      scheme: bearer
      description: >-
        ##Alle APIs erfordern eine Bearer-Token-Authentifizierung##


        **API-Schlüssel abrufen:**


        Besuchen Sie die
        [API-Schlüsselverwaltung](https://evolink.ai/dashboard/keys), um Ihren
        API-Schlüssel abzurufen


        **Zum Anfrage-Header hinzufügen:**

        ```

        Authorization: Bearer YOUR_API_KEY

        ```

````

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