GPT 2.6, Veo 3.1, Seedance 2.5, Kling 4 in deAPI!
Web-search and web-contents are now available via API
Browse all Models
Browse all
Browse all
Browse all

LLM · Vision

Kimi K3 API, kostenlos testen

Kimi K3 ist ein Reasoning-fähiges Large Language Model mit offenen Gewichten von Moonshot AI. Es liest Text und Bilder und fasst bis zu 1 Mio. Tokens Kontext. deAPI stellt es über einen OpenAI-kompatiblen Endpoint bereit. Das OpenAI SDK funktioniert also, sobald du Base-URL, Key und Modell-ID änderst.

  • Text und Bilder als Input, Kontextfenster von 1.000.000 Tokens
  • Output nach JSON-Schema, Tool Calls und Streaming
  • reasoning_effort in sieben Stufen, von none bis max

Keine Kreditkarte nötig · Gratis-Guthaben 30 Tage gültig · Danach Guthaben aufladen und nach Verbrauch zahlen, kein Abo

Kimi K3 LLM · Vision

model: "kimi-k3"
reasoning_effort: "low"

system: You are a senior JavaScript engineer. Explain the bug in two sentences, then give the fixed function. Plain prose without labels or bold, nothing after the code.

user

Why does this always return 0?

async function total(ids) {
  let sum = 0;
  ids.forEach(async (id) => {
    sum += await getPrice(id);
  });
  return sum;
}
assistant reasoning_content · 8 Tokens

forEach fires off the async callbacks but doesn’t await them, so the function returns before any of the awaits resolve and sum is still 0. The callbacks also mutate a closed-over variable later, after the return value has already been captured.

async function total(ids) {
  const prices = await Promise.all(ids.map((id) => getPrice(id)));
  return prices.reduce((sum, price) => sum + price, 0);
}
180 Input- + 113 Output-Tokens (8 Reasoning) · 4,1 s Kosten bei deAPI: 0,0025 $ (Preisstand November 2026)

Anwendungsfälle für Kimi K3

Vier Aufgaben, für die das Modell passt, jede mit der Zahl dahinter. Alle laufen mit demselben deAPI-Key wie Transkription, OCR und Bildgenerierung.

  1. Rechnungen, Belege und Formulare. Sende ein Foto oder einen Scan als image_url zusammen mit einem JSON-Schema. Bei der generierten deutschen Rechnung unten lieferte es in beiden von zwei Durchläufen alle 10 Felder, mit Datumsangaben im ISO-Format und Beträgen als Zahlen. Moonshot AI nennt 91,1 auf OmniDocBench mit Reasoning-Effort max.

  2. Code-Review und Coding-Agenten. Die Frage oben ist ein echter Aufruf: 113 Output-Tokens für Ursache und Fix. Mit Reasoning-Effort max und dem eigenen Kimi-Code-Harness nennt Moonshot AI 67,5 auf DeepSWE (v1.1-Aufgaben) und 88,3 auf Terminal-Bench 2.1. Coding-Tools, die die OpenAI Chat Completions API sprechen, kannst du auf https://oai.deapi.ai/v1 richten.

  3. Lange Transkripte und Dokumente. Das Kontextfenster fasst 1.000.000 Tokens, Prompt und Antwort zusammen, und eine Antwort kann bis zu 131.072 Tokens lang sein. Transkribiere die Sales-Calls eines Tages mit WhisperLargeV3Ct2 und frag in einer Anfrage nach Einwänden, Follow-ups und Zitaten.

  4. Agenten, die deAPI aufrufen. Beschreibe deAPI-Endpoints als Tools. Nach Kapiteln mit Zeitstempeln für ein YouTube-Video gefragt, rief das Modell transcribe_video mit der Video-URL und include_ts: true auf (ein Durchlauf). Dein Code führt diesen Aufruf aus und schickt das Transkript zurück.

Deutsche Rechnung der Nordlicht Studio GmbH mit drei Positionen und einer Summe von 2.677,50 EUR
Antwort: message.content
{
  "invoice_number": "NS-2026-0418",
  "issue_date": "2026-11-03",
  "due_date": "2026-11-17",
  "seller": "Nordlicht Studio GmbH",
  "seller_vat_id": "DE298765431",
  "net": 2250.0,
  "vat": 427.5,
  "total": 2677.5,
  "currency": "EUR",
  "iban": "DE44 1001 0010 0123 4567 89"
}
Rechnungsbeispiel: Bild rein, JSON raus System: „Extract invoice fields. Dates as YYYY-MM-DD, amounts as numbers.“ User: „Extract the fields from this invoice.“ JSON-Schema mit 10 Feldern, Temperatur 0. 1.426 Input- + 332 Output-Tokens (234 Reasoning), 7,7 s beim ersten Aufruf.

Kimi K3 API Preise

Du zahlst pro Token aus demselben Prepaid-Guthaben wie bei jedem anderen deAPI-Modell. Reasoning-Tokens sind Teil von completion_tokens in usage. Kein Abo.

Input (Text und Bilder) 3,30 $ ≈ 1,5 Mio. Tokens
Gecachter Input (wiederholtes Prompt-Präfix) 0,33 $ ≈ 15 Mio. Tokens
Output (Antwort und Reasoning) 16,50 $ ≈ 0,3 Mio. Tokens
Frage im Hero, ein Aufruf 0,0025 $ ≈ 2.000 Aufrufe
Rechnungsbeispiel, ein Aufruf 0,01 $ ≈ 490 Aufrufe

Das bekommst du mit dem Gratis-Konto

  • 5 $ Guthaben, sobald du eine Zahlungskarte hinterlegt hast
  • Etwa 2.000 Aufrufe wie die Frage im Hero
  • Guthaben 30 Tage gültig, danach aufladen und nach Verbrauch zahlen
5 $ Guthaben sichern

Preise für kimi-k3 in USD, November 2026. Token-Zahlen aus der Frage im Hero und dem Rechnungsbeispiel; ein Rechnungsaufruf kostet 0,01 $. Kontext- und Output-Limits aus GET https://oai.deapi.ai/v1/models.

Kimi K3 vs. Qwen3.8 Max vs. GLM-5.3

Input Text, Bild Text, Bild Text
Kontext 1.000.000 Tokens 1.000.000 Tokens 1.000.000 Tokens
Max. Output 131.072 Tokens 131.072 Tokens 131.072 Tokens
reasoning_effort none bis max, 7 Stufen none bis max, 7 Stufen low, high oder max
Strukturierter Output json_schema, json_object json_schema, json_object json_object
Preis pro 1 Mio., Input / Output 3,30 $ / 16,50 $ 2,20 $ / 6,60 $ 1,54 $ / 4,84 $

Modell-IDs: kimi-k3, qwen3.8-max, glm-5.3. Limits und Input-Typen aus GET /v1/models. Reasoning-Stufen und Output-Formate getestet am 16. November 2026.

Beispiel für die Kimi K3 API

Ein POST an https://oai.deapi.ai/v1/chat/completions mit deinem deAPI-Key als Bearer-Token. Im OpenAI SDK setzt du base_url, deinen deAPI-Key und die Modell-ID; der Rest eines Chat-Completions-Aufrufs bleibt gleich. Ersetze YOUR_API_KEY durch einen Key aus deinem Dashboard.

Modell-ID
kimi-k3
Endpoint
POST https://oai.deapi.ai/v1/chat/completions
Input
Text und Bilder als image_url-Parts: eine Base64-Data-URL oder ein öffentlicher HTTPS-Link. PDFs und Audio werden abgelehnt.
Kontext und Output
Kontextfenster von 1.000.000 Tokens (Prompt und Antwort zusammen), bis zu 131.072 Tokens pro Antwort
Reasoning
reasoning_effort: none, minimal, low, medium, high, xhigh oder max. Das Reasoning kommt in reasoning_content zurück.
Output-Optionen
response_format mit json_schema (strict) oder json_object, tools, stream
curl https://oai.deapi.ai/v1/chat/completions \
  -H 'Authorization: Bearer YOUR_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{
    "model": "kimi-k3",
    "reasoning_effort": "none",
    "messages": [
      {"role": "system", "content": "Sort support tickets. Reply with one word: billing, bug, feature or other."},
      {"role": "user", "content": "I was charged twice for the November top-up."}
    ]
  }'
import base64, json
from openai import OpenAI

client = OpenAI(base_url="https://oai.deapi.ai/v1", api_key="YOUR_API_KEY")

with open("invoice.png", "rb") as f:
    image = "data:image/png;base64," + base64.b64encode(f.read()).decode()

schema = {
    "type": "object",
    "additionalProperties": False,
    "required": ["invoice_number", "issue_date", "due_date", "seller",
                 "seller_vat_id", "net", "vat", "total", "currency", "iban"],
    "properties": {
        "invoice_number": {"type": "string"},
        "issue_date": {"type": "string"},
        "due_date": {"type": "string"},
        "seller": {"type": "string"},
        "seller_vat_id": {"type": "string"},
        "net": {"type": "number"},
        "vat": {"type": "number"},
        "total": {"type": "number"},
        "currency": {"type": "string"},
        "iban": {"type": "string"},
    },
}

response = client.chat.completions.create(
    model="kimi-k3",
    temperature=0,
    messages=[
        {"role": "system", "content": "Extract invoice fields. "
         "Dates as YYYY-MM-DD, amounts as numbers."},
        {"role": "user", "content": [
            {"type": "text", "text": "Extract the fields from this invoice."},
            {"type": "image_url", "image_url": {"url": image}},
        ]},
    ],
    response_format={"type": "json_schema",
                     "json_schema": {"name": "invoice", "strict": True, "schema": schema}},
)

invoice = json.loads(response.choices[0].message.content)
print(invoice["total"], invoice["currency"])  # 2677.5 EUR
print(response.usage)

Was ist Kimi K3?

Kimi K3 ist ein Mixture-of-Experts-Modell mit offenen Gewichten, das Moonshot AI unter der eigenen Kimi K3 License veröffentlicht. Es hat insgesamt 2,8 Billionen Parameter und aktiviert davon 104 Mrd. pro Token, indem es 16 von 896 Experten auswählt. Ein Vision-Encoder mit 401 Mio. Parametern, MoonViT-V2, liest die Bilder. Es schreibt Text und kann vor der Antwort Reasoning einsetzen. Auf deAPI rufst du es wie jedes OpenAI-Chat-Modell auf und zahlst pro Token.

  1. Gratis-Konto anlegen

    Registriere dich und hol dir 5 $ Guthaben.

  2. Client auf deAPI umstellen

    Setze base_url auf https://oai.deapi.ai/v1 und nutze deinen deAPI-Key.

  3. Anfrage senden

    Nimm kimi-k3 als Modell und lies die Antwort aus choices[0].message.content.

FAQ zu Kimi K3

Ja. deAPI stellt das Modell unter https://oai.deapi.ai/v1 mit der Modell-ID kimi-k3 bereit, im Request- und Response-Format der OpenAI Chat Completions API. Wenn dein Code schon das OpenAI SDK nutzt, änderst du drei Werte: base_url, den API-Key und das Modell. Teste selbst, bevor du Traffic umstellst.
Ein neues deAPI-Konto bekommt 5 $ Guthaben, sobald eine Zahlungskarte hinterlegt ist. Das reicht für etwa 2.000 Aufrufe wie die Code-Frage oben auf dieser Seite. Das Guthaben ist 30 Tage gültig. Danach lädst du Guthaben auf und zahlst nach Verbrauch, ohne Abo.
3,30 $ pro Million Input-Tokens, 0,33 $ pro Million gecachte Input-Tokens und 16,50 $ pro Million Output-Tokens (November 2026). Reasoning-Tokens zählen als Output, und du siehst sie in usage.completion_tokens_details.reasoning_tokens.
Ja. Füge der User-Nachricht einen image_url-Part hinzu, als Base64-Data-URL oder öffentlichen HTTPS-Link. PDFs und Audiodateien werden abgelehnt: Schick PDFs durch die OCR API oder sende die Seiten als Bilder, und transkribiere Audio vorher.
Auf deAPI umfasst das Kontextfenster 1.000.000 Tokens, Prompt und Antwort zusammen, und eine Antwort kann bis zu 131.072 Tokens lang sein. Die Model Card von Moonshot AI nennt für das Modell selbst eine Kontextlänge von 1.048.576 Tokens.
Die Model Card von Moonshot AI nennt mit Reasoning-Effort max: 93,5 auf GPQA Diamond, 67,5 auf DeepSWE (v1.1-Aufgaben) und 88,3 auf Terminal-Bench 2.1 (beide mit dem Kimi-Code-Harness). Bei Bildern nennt sie 91,1 auf OmniDocBench und 81,6 auf MMMU-Pro ohne Tools. Das sind die Zahlen von Moonshot AI; teste das Modell mit dem Gratis-Guthaben an deinen eigenen Daten.
Setze reasoning_effort auf none. Bei der Ticket-Anfrage aus dem cURL-Beispiel antwortete none „billing“ mit 7 Output-Tokens und ohne Reasoning-Tokens. high gab dieselbe Antwort mit 19 Output-Tokens, davon 6 Reasoning (je ein Durchlauf). Die Stufen dazwischen sind minimal, low und medium; über high liegen xhigh und max.
Moonshot AI veröffentlicht die Gewichte auf Hugging Face unter der Kimi K3 License. Das ist eine eigene Lizenz von Moonshot AI mit zusätzlichen Bedingungen für große Model-as-a-Service-Anbieter und sehr große Produkte. Lies sie also, bevor du die Gewichte selbst hostest. Für Aufrufe über deAPI gelten die deAPI Terms of Service.

Sende deine erste Anfrage an Kimi K3 mit 5 $ Gratis-Guthaben

Registrierung mit E-Mail oder Google. Kein Abo, Abrechnung nach Verbrauch.