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

API Kimi K3, da provare gratis

Kimi K3 è un modello linguistico di grandi dimensioni a pesi aperti di Moonshot AI, capace di ragionare. Legge testo e immagini e gestisce fino a 1M di token di contesto. deAPI lo offre su un endpoint compatibile con OpenAI, quindi l’SDK OpenAI funziona appena cambi base URL, chiave e ID del modello.

  • Testo e immagini in input, finestra di contesto da 1.000.000 di token
  • Output con JSON schema, tool call e streaming
  • reasoning_effort su sette livelli, da none a max

Nessuna carta di credito · Crediti gratuiti validi 30 giorni · Poi ricarichi il saldo e paghi a consumo, senza abbonamento

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 token

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 token di input + 113 di output (8 di ragionamento) · 4,1 s Costo su deAPI: 0,0025 $ (prezzo di novembre 2026)

Casi d’uso di Kimi K3

Quattro compiti adatti al modello, ognuno con il numero che lo dimostra. Tutti funzionano con la stessa chiave deAPI che usi per trascrizione, OCR e generazione di immagini.

  1. Fatture, ricevute e moduli. Invia una foto o una scansione come image_url insieme a un JSON schema. Sulla fattura tedesca generata qui sotto ha restituito tutti i 10 campi in tutte e due le esecuzioni, con le date in formato ISO e gli importi come numeri. Moonshot AI riporta 91,1 su OmniDocBench con reasoning effort max.

  2. Code review e agenti di programmazione. La domanda qui sopra è una chiamata reale: 113 token di output per la causa e la correzione. Con reasoning effort max e il proprio harness Kimi Code, Moonshot AI riporta 67,5 su DeepSWE (task v1.1) e 88,3 su Terminal-Bench 2.1. Gli strumenti di coding che usano l’API OpenAI Chat Completions possono puntare a https://oai.deapi.ai/v1.

  3. Trascrizioni e documenti lunghi. La finestra di contesto contiene 1.000.000 di token, prompt e risposta insieme, e una risposta può arrivare a 131.072. Trascrivi una giornata di chiamate di vendita con WhisperLargeV3Ct2 e chiedi obiezioni, follow-up e citazioni in una sola richiesta.

  4. Agenti che chiamano deAPI. Descrivi gli endpoint di deAPI come tool. Alla richiesta dei capitoli con timestamp di un video YouTube, il modello ha chiamato transcribe_video con l’URL del video e include_ts: true (una sola esecuzione). Il tuo codice esegue quella chiamata e rimanda indietro la trascrizione.

Fattura tedesca di Nordlicht Studio GmbH con tre voci e un totale di 2.677,50 EUR
Risposta: 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"
}
Esempio della fattura: immagine in input, JSON in output System: “Extract invoice fields. Dates as YYYY-MM-DD, amounts as numbers.” User: “Extract the fields from this invoice.” JSON schema con 10 campi, temperature 0. 1.426 token di input + 332 di output (234 di ragionamento), 7,7 s alla prima chiamata.

Prezzi dell’API Kimi K3

Paghi a token dallo stesso saldo prepagato di tutti gli altri modelli deAPI. I token di ragionamento rientrano in completion_tokens di usage. Nessun abbonamento.

Input (testo e immagini) 3,30 $ ≈ 1,5M di token
Input in cache (prefisso del prompt ripetuto) 0,33 $ ≈ 15M di token
Output (risposta e ragionamento) 16,50 $ ≈ 0,3M di token
Domanda in cima alla pagina, una chiamata 0,0025 $ ≈ 2.000 chiamate
Esempio della fattura, una chiamata 0,01 $ ≈ 490 chiamate

Cosa include l’account gratuito

  • $5 di crediti dopo aver aggiunto una carta di pagamento
  • Circa 2.000 chiamate come la domanda in cima alla pagina
  • Crediti validi 30 giorni, poi ricarichi il saldo e paghi a consumo
Ottieni $5 di crediti gratis

Prezzi per kimi-k3 in USD, novembre 2026. Conteggi dei token presi dalla domanda in cima alla pagina e dall’esempio della fattura; una chiamata sulla fattura costa 0,01 $. Limiti di contesto e di output da GET https://oai.deapi.ai/v1/models.

Kimi K3 vs Qwen3.8 Max vs GLM-5.3

Input Testo, immagini Testo, immagini Testo
Contesto 1.000.000 token 1.000.000 token 1.000.000 token
Output massimo 131.072 token 131.072 token 131.072 token
reasoning_effort da none a max, 7 livelli da none a max, 7 livelli low, high o max
Output strutturato json_schema, json_object json_schema, json_object json_object
Prezzo per 1M, input / output 3,30 $ / 16,50 $ 2,20 $ / 6,60 $ 1,54 $ / 4,84 $

ID dei modelli: kimi-k3, qwen3.8-max, glm-5.3. Limiti e tipi di input da GET /v1/models. Livelli di ragionamento e formati di output testati il 16 novembre 2026.

Esempio di API Kimi K3

Una POST a https://oai.deapi.ai/v1/chat/completions con la tua chiave deAPI come Bearer token. Nell’SDK OpenAI imposta base_url, la tua chiave deAPI e l’ID del modello; il resto di una chiamata Chat Completions resta uguale. Sostituisci YOUR_API_KEY con una chiave dalla tua dashboard.

ID modello
kimi-k3
Endpoint
POST https://oai.deapi.ai/v1/chat/completions
Input
Testo e immagini come parti image_url: un data URL base64 o un link HTTPS pubblico. PDF e audio vengono rifiutati.
Contesto e output
Finestra di contesto da 1.000.000 di token (prompt e risposta insieme), fino a 131.072 token per risposta
Ragionamento
reasoning_effort: none, minimal, low, medium, high, xhigh o max. Il ragionamento torna in reasoning_content.
Opzioni di output
response_format con json_schema (strict) o 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)

Cos’è Kimi K3?

Kimi K3 è un modello Mixture-of-Experts a pesi aperti che Moonshot AI pubblica con una licenza propria, la Kimi K3 License. Ha 2.800 miliardi di parametri in totale e ne attiva 104 miliardi per token, scegliendo 16 esperti su 896. Le immagini le legge MoonViT-V2, un encoder visivo da 401 milioni di parametri. Scrive testo e può ragionare prima di rispondere. Su deAPI lo chiami come qualsiasi modello chat di OpenAI e paghi a token.

  1. Crea un account gratuito

    Registrati e ricevi $5 di crediti.

  2. Punta il tuo client a deAPI

    Imposta base_url su https://oai.deapi.ai/v1 e usa la tua chiave deAPI.

  3. Invia la richiesta

    Usa kimi-k3 come modello e leggi la risposta da choices[0].message.content.

FAQ su Kimi K3

Sì. deAPI lo offre su https://oai.deapi.ai/v1 con l’ID modello kimi-k3, nel formato di richiesta e risposta dell’API OpenAI Chat Completions. Se il tuo codice usa già l’SDK OpenAI, cambi tre valori: base_url, la chiave API e il modello. Fai i tuoi test prima di spostare il traffico.
Un nuovo account deAPI riceve $5 di crediti dopo aver aggiunto una carta di pagamento, sufficienti per circa 2.000 chiamate come la domanda sul codice in cima a questa pagina. I crediti sono validi 30 giorni. Dopo ricarichi il saldo e paghi a consumo, senza abbonamento.
3,30 $ per milione di token di input, 0,33 $ per milione di token di input in cache e 16,50 $ per milione di token di output (novembre 2026). I token di ragionamento contano come output e li vedi in usage.completion_tokens_details.reasoning_tokens.
Sì. Aggiungi una parte image_url al messaggio utente, come data URL base64 o link HTTPS pubblico. PDF e file audio vengono rifiutati: passa i PDF dall’API OCR oppure invia le pagine come immagini, e trascrivi prima l’audio.
Su deAPI la finestra di contesto è di 1.000.000 di token, prompt e risposta insieme, e una risposta può essere lunga fino a 131.072 token. La model card di Moonshot AI indica per il modello in sé una lunghezza di contesto di 1.048.576 token.
Dalla model card di Moonshot AI, con reasoning effort max: 93,5 su GPQA Diamond, 67,5 su DeepSWE (task v1.1) e 88,3 su Terminal-Bench 2.1 (entrambi con l’harness Kimi Code). Per le immagini riporta 91,1 su OmniDocBench e 81,6 su MMMU-Pro senza tool. Sono numeri di Moonshot AI; provalo sui tuoi dati con i crediti gratuiti.
Imposta reasoning_effort su none. Sulla richiesta del ticket dell’esempio cURL, none ha risposto “billing” con 7 token di output e nessun token di ragionamento. high ha dato la stessa risposta con 19 token di output, di cui 6 di ragionamento (una sola esecuzione ciascuno). I livelli intermedi sono minimal, low e medium; sopra high ci sono xhigh e max.
Moonshot AI pubblica i pesi su Hugging Face con la Kimi K3 License. È una licenza propria di Moonshot AI, con condizioni aggiuntive per le grandi attività model-as-a-service e per i prodotti molto grandi, quindi leggila prima di ospitare i pesi in proprio. Le chiamate tramite deAPI sono regolate dai Termini di servizio di deAPI.

Invia la tua prima richiesta a Kimi K3 con $5 di crediti gratis

Registrati con email o Google. Paghi a consumo, senza abbonamento.