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, free to try

Kimi K3 is an open-weight large language model from Moonshot AI that can reason. It reads text and images and holds up to 1M tokens of context. deAPI serves it on an OpenAI-compatible endpoint, so the OpenAI SDK works once you change the base URL, the key and the model ID.

  • Text and images in, a 1,000,000-token context window
  • JSON schema output, tool calls and streaming
  • reasoning_effort in seven levels, from none to max

No credit card · Free credits valid for 30 days · Then top up and pay as you go, no subscription

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 Cost on deAPI: $0.0025 (price as of November 2026)

Kimi K3 use cases

Four jobs where the model fits, each with the number behind it. All of them run on the same deAPI key as transcription, OCR and image generation.

  1. Invoices, receipts and forms. Send a photo or scan as image_url with a JSON schema. On the generated German invoice below it returned all 10 fields in both of two runs, with dates in ISO format and amounts as numbers. Moonshot AI reports 91.1 on OmniDocBench at max reasoning effort.

  2. Code review and coding agents. The question above is a real call: 113 output tokens for the cause and the fix. At max reasoning effort with its Kimi Code harness, Moonshot AI reports 67.5 on DeepSWE (v1.1 tasks) and 88.3 on Terminal-Bench 2.1. Coding tools that speak the OpenAI Chat Completions API can point at https://oai.deapi.ai/v1.

  3. Long transcripts and documents. The context window holds 1,000,000 tokens, prompt and answer together, and one answer can run to 131,072. Transcribe a day of sales calls with WhisperLargeV3Ct2 and ask for objections, follow-ups and quotes in one request.

  4. Agents that call deAPI. Describe deAPI endpoints as tools. Asked for chapters with timestamps for a YouTube video, the model called transcribe_video with the video URL and include_ts: true (one run). Your code runs that call and sends the transcript back.

German invoice from Nordlicht Studio GmbH with three line items and a total of 2,677.50 EUR
Response: 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"
}
Invoice example: image in, JSON out System: “Extract invoice fields. Dates as YYYY-MM-DD, amounts as numbers.” User: “Extract the fields from this invoice.” JSON schema with 10 fields, temperature 0. 1,426 input + 332 output tokens (234 reasoning), 7.7 s on the first call.

Kimi K3 API pricing

You pay per token from the same prepaid balance as every other deAPI model. Reasoning tokens are part of completion_tokens in usage. No subscription.

Input (text and images) $3.30 ≈ 1.5M tokens
Cached input (repeated prompt prefix) $0.33 ≈ 15M tokens
Output (answer and reasoning) $16.50 ≈ 0.3M tokens
Question in the hero, one call $0.0025 ≈ 2,000 calls
Invoice example, one call $0.01 ≈ 490 calls

What the free account includes

  • $5 of credits once you add a payment card
  • About 2,000 calls like the question in the hero
  • Credits valid for 30 days, then top up and pay as you go
Get $5 credits

Prices for kimi-k3 in USD, November 2026. Token counts from the hero question and the invoice example; one invoice call costs $0.01. Context and output limits from GET https://oai.deapi.ai/v1/models.

Kimi K3 vs Qwen3.8 Max vs GLM-5.3

Input Text, image Text, image Text
Context 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 to max, 7 levels none to max, 7 levels low, high or max
Structured output json_schema, json_object json_schema, json_object json_object
Price per 1M, input / output $3.30 / $16.50 $2.20 / $6.60 $1.54 / $4.84

Model IDs: kimi-k3, qwen3.8-max, glm-5.3. Limits and input types from GET /v1/models. Reasoning levels and output formats tested on 16 November 2026.

Kimi K3 API example

One POST to https://oai.deapi.ai/v1/chat/completions with your deAPI key as the Bearer token. In the OpenAI SDK, set base_url, your deAPI key and the model ID; the rest of a Chat Completions call stays the same. Replace YOUR_API_KEY with a key from your dashboard.

Model ID
kimi-k3
Endpoint
POST https://oai.deapi.ai/v1/chat/completions
Input
Text and images as image_url parts: a base64 data URL or a public HTTPS link. PDFs and audio are rejected.
Context and output
1,000,000-token context window (prompt and answer together), up to 131,072 tokens per answer
Reasoning
reasoning_effort: none, minimal, low, medium, high, xhigh or max. The reasoning comes back in reasoning_content.
Output options
response_format with json_schema (strict) or 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)

What is Kimi K3?

Kimi K3 is an open-weight Mixture-of-Experts model that Moonshot AI publishes under its own Kimi K3 License. It has 2.8T parameters in total and activates 104B of them per token, choosing 16 of 896 experts. A 401M-parameter vision encoder, MoonViT-V2, reads the images. It writes text and can reason before it answers. On deAPI you call it like any OpenAI chat model and pay per token.

  1. Create a free account

    Sign up and get $5 of credits.

  2. Point your client at deAPI

    Set base_url to https://oai.deapi.ai/v1 and use your deAPI key.

  3. Send the request

    Use kimi-k3 as the model and read the answer from choices[0].message.content.

Kimi K3 FAQ

Yes. deAPI serves it at https://oai.deapi.ai/v1 under the model ID kimi-k3, with the request and response format of the OpenAI Chat Completions API. If your code already uses the OpenAI SDK, you change three values: base_url, the API key and the model. Run your own tests before you switch traffic.
A new deAPI account gets $5 of credits once you add a payment card, enough for about 2,000 calls like the code question at the top of this page. The credits are valid for 30 days. After that you top up and pay as you go, with no subscription.
$3.30 per million input tokens, $0.33 per million cached input tokens and $16.50 per million output tokens (November 2026). Reasoning tokens count as output, and you see them in usage.completion_tokens_details.reasoning_tokens.
Yes. Add an image_url part to the user message, as a base64 data URL or a public HTTPS link. PDFs and audio files are rejected: run PDFs through the OCR API or send pages as images, and transcribe audio first.
On deAPI the context window is 1,000,000 tokens, prompt and answer together, and one answer can be up to 131,072 tokens long. Moonshot AI’s model card lists a context length of 1,048,576 tokens for the model itself.
Moonshot AI’s model card, at max reasoning effort: 93.5 on GPQA Diamond, 67.5 on DeepSWE (v1.1 tasks) and 88.3 on Terminal-Bench 2.1 (both with the Kimi Code harness). For images it lists 91.1 on OmniDocBench and 81.6 on MMMU-Pro without tools. These are Moonshot AI’s numbers; test it on your own data with the free credits.
Set reasoning_effort to none. On the ticket request from the cURL example, none answered “billing” with 7 output tokens and no reasoning tokens. high gave the same answer with 19 output tokens, 6 of them reasoning (one run each). The levels in between are minimal, low and medium; above high come xhigh and max.
Moonshot AI publishes the weights on Hugging Face under the Kimi K3 License. It is Moonshot AI’s own license, with extra conditions for large model-as-a-service businesses and very large products, so read it before you host the weights yourself. Calls through deAPI are covered by the deAPI Terms of Service.

Send your first Kimi K3 request with $5 of free credits

Sign up with e-mail or Google. No subscription, pay as you go.