Blog

Cara Menggunakan API Kimi K3

Panggil API Kimi K3 dengan OpenAI SDK: panduan cepat Python, JavaScript, dan cURL, ditambah streaming, panggilan alat, mode JSON, upaya penalaran, dan caching.

Ashley Innocent

Ashley Innocent

17 July 2026

Cara Menggunakan API Kimi K3

Apidog untuk Perusahaan

Penerapan On-Premises

SSO & RBAC

Sesuai SOC 2

Jelajahi Apidog Enterprise

Moonshot AI merilis Kimi K3 pada 16 Juli 2026, dan menyebutnya sebagai model paling mumpuni mereka hingga saat ini: model kelas 3T terbuka pertama di dunia, dengan desain Mixture-of-Experts 2.8T-parameter dan jendela konteks 1.048.576-token. Bagian menarik bagi para pengembang bukanlah ukurannya, melainkan API-nya. Kimi K3 berbicara dalam dialek OpenAI SDK, jadi jika Anda sudah memanggil GPT atau *endpoint* yang kompatibel dengan OpenAI lainnya, Anda dapat mengarahkan klien yang sama ke `kimi-k3` dan mulai *streaming* respons dalam beberapa menit. Panduan ini akan membahas cara mendapatkan kunci, *quickstart* dalam Python, JavaScript, dan cURL, *streaming*, panggilan alat (*tool calls*), mode JSON, parameter upaya penalaran (*reasoning-effort*) yang dapat dikonfigurasi, dan *caching* konteks yang membuat *input cache-hit* kira-kira sepuluh kali lebih murah daripada *cache-miss*. Kemudian Anda akan menguji dan *debug* panggilan tersebut di Apidog sehingga Anda dapat melihat permintaan mentah dan *server-sent events* alih-alih menebak-nebak.

Intinya

Model Kimi mana yang harus Anda panggil

Sebelum Anda menulis kode apa pun, pilih target yang tepat. Kimi K3 adalah model *frontier* dalam keluarga ini: MoE besar yang ditujukan untuk pengkodean kompleks, pekerjaan agen jangka panjang, dan tugas pengetahuan dalam konteks yang panjang. Model ini memiliki biaya *output* per token tertinggi dalam jajaran, dan pos peluncuran Moonshot sendiri secara jujur menyatakan bahwa K3 masih tertinggal dari Claude Fable 5 dan GPT-5.6 Sol dalam perbandingan internal mereka. Model ini kuat, bukan pemenang *frontier* yang jelas, dan harganya disesuaikan.

Jika beban kerja Anda adalah asisten pengkodean bervolume tinggi, penulis uji CI, atau apa pun di mana Anda membayar per panggilan dalam skala besar, lini K2.7 Code yang lebih lama seringkali lebih cocok dalam hal biaya. Mulai dengan panduan API Kimi K2.7 Code dan ikhtisar apa itu Kimi K2.7 Code untuk melihat apakah tingkatan tersebut sesuai dengan kasus Anda. Untuk perbandingan kemampuan dan harga secara berdampingan, perbandingan Kimi K3 vs Kimi K2.7 Code menjelaskan di mana masing-masing unggul. Gunakan `kimi-k3` ketika Anda membutuhkan kedalaman penalaran ekstra, konteks penuh 1 juta, atau orkestrasi alat agen; gunakan K2.7 ketika tugasnya rutin dan volumenya tinggi. Jika Anda ingin ikhtisar kemampuan lengkap terlebih dahulu, penjelasan apa itu Kimi K3 mencakup arsitektur dan posisi model tersebut.

Dapatkan kunci API di platform Kimi

Kunjungi platform.kimi.ai dan masuk. Konsol baru adalah tempat Anda membuat kunci, memantau penggunaan, dan mengonfirmasi URL dasar untuk akun Anda.

  1. Buka bagian kunci API di konsol dan buat kunci baru.
  2. Salin sekali dan simpan di tempat yang aman. Anda tidak akan melihat nilai lengkapnya lagi.
  3. Tambahkan kredit atau konfirmasi tingkatan tagihan Anda agar panggilan ke `kimi-k3` tidak ditolak karena saldo tidak mencukupi.
  4. Catat URL dasar yang ditampilkan di konsol. Kimi secara historis menggunakan `https://api.moonshot.ai/v1`; konsol adalah sumber kebenaran untuk akun Anda.

Ekspor kunci sebagai variabel lingkungan agar tidak pernah masuk ke kode sumber Anda:

export KIMI_API_KEY="sk-your-key-here"

Kebiasaan sederhana itu menjaga rahasia agar tidak masuk ke riwayat *git* dan keluar dari tangkapan layar. Nanti, saat Anda menguji di Apidog, Anda juga akan menyimpan nilai yang sama sebagai variabel lingkungan di sana, sehingga kunci tersebut hanya berada di dua tempat yang Anda kontrol.

Untuk rincian lengkap perhitungan *cache-hit* versus *cache-miss* dan bagaimana kaitannya dengan tagihan bulanan riil, lihat panduan harga Kimi K3.

Mulai Cepat: panggilan kimi-k3 pertama Anda

API Kimi mengikuti kontrak *chat-completions* OpenAI, sehingga SDK OpenAI resmi berfungsi dengan dua perubahan: `base_url` dan `model`. Instal SDK yang Anda inginkan, lalu jalankan salah satu cuplikan di bawah ini.

Python

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ["KIMI_API_KEY"],
    # Kimi kompatibel dengan OpenAI-SDK. Konfirmasi URL dasar yang tepat di
    # konsol di platform.kimi.ai; Kimi secara historis menggunakan nilai di bawah ini.
    base_url="https://api.moonshot.ai/v1",
)

response = client.chat.completions.create(
    model="kimi-k3",
    messages=[
        {"role": "system", "content": "You are a precise coding assistant."},
        {"role": "user", "content": "Explain what a token bucket rate limiter does in one paragraph."},
    ],
)

print(response.choices[0].message.content)

JavaScript / TypeScript

import OpenAI from "openai";

const client = new OpenAI({
  apiKey: process.env.KIMI_API_KEY,
  // Konfirmasi URL dasar di konsol platform.kimi.ai.
  baseURL: "https://api.moonshot.ai/v1",
});

const response = await client.chat.completions.create({
  model: "kimi-k3",
  messages: [
    { role: "system", content: "You are a precise coding assistant." },
    { role: "user", content: "Explain what a token bucket rate limiter does in one paragraph." },
  ],
});

console.log(response.choices[0].message.content);

cURL

curl "$KIMI_BASE_URL/chat/completions" \
  -H "Authorization: Bearer $KIMI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "kimi-k3",
    "messages": [
      {"role": "user", "content": "Explain what a token bucket rate limiter does in one paragraph."}
    ]
  }'

Atur `KIMI_BASE_URL` sesuai dengan yang ditampilkan di konsol (misalnya `https://api.moonshot.ai/v1`). Jika salah satu dari ini mengembalikan 401, kuncinya salah atau tidak diatur. 404 pada jalur biasanya berarti URL dasar tidak tepat, bukan modelnya hilang. Dokumentasi OpenAI Python SDK membahas opsi klien secara lebih rinci, dan setiap opsi di sana berlaku di sini karena format *wire* (jaringan) yang sama.

Streaming respons

Untuk UI *chat* dan giliran agen yang panjang, Anda ingin token tiba saat mereka dihasilkan daripada menunggu seluruh *completion*. Atur `stream=True` dan iterasi di atas delta.

stream = client.chat.completions.create(
    model="kimi-k3",
    messages=[{"role": "user", "content": "Write a 6-line poem about flaky tests."}],
    stream=True,
)

for chunk in stream:
    delta = chunk.choices[0].delta
    if delta.content:
        print(delta.content, end="", flush=True)

Di balik layar, ini adalah aliran *server-sent events* (SSE): setiap baris adalah *frame* `data:` yang membawa potongan JSON kecil, dan aliran berakhir dengan `data: [DONE]`. SDK menyembunyikan *framing* itu dari Anda, yang nyaman hingga sesuatu rusak di tengah aliran dan Anda perlu melihat *frame* mentahnya. Di sinilah bagian Apidog di bawah ini sangat berguna.

const stream = await client.chat.completions.create({
  model: "kimi-k3",
  messages: [{ role: "user", content: "Write a 6-line poem about flaky tests." }],
  stream: true,
});

for await (const chunk of stream) {
  process.stdout.write(chunk.choices[0]?.delta?.content ?? "");
}

Panggilan Alat (pemanggilan fungsi)

Kimi K3 mendukung panggilan alat (*tool calls*), batasan pilihan alat (*tool-choice*), dan pemuatan alat dinamis, sehingga Anda dapat mengintegrasikannya ke dalam agen yang membaca *file*, memanggil API, atau menjalankan perintah terminal. Anda menjelaskan fungsi Anda dengan JSON Schema, model memutuskan kapan harus memanggil salah satunya, dan Anda mengembalikan hasilnya pada pesan `tool`.

tools = [
    {
        "type": "function",
        "function": {
            "name": "get_weather",
            "description": "Get the current weather for a city.",
            "parameters": {
                "type": "object",
                "properties": {
                    "city": {"type": "string", "description": "City name, e.g. Singapore"},
                },
                "required": ["city"],
            },
        },
    }
]

messages = [{"role": "user", "content": "What's the weather in Singapore right now?"}]

first = client.chat.completions.create(
    model="kimi-k3",
    messages=messages,
    tools=tools,
    tool_choice="auto",
)

tool_call = first.choices[0].message.tool_calls[0]
print(tool_call.function.name)       # get_weather
print(tool_call.function.arguments)  # {"city": "Singapore"}

Model tidak menjalankan fungsi Anda; ia memberikan nama dan argumen JSON kepada Anda. Anda menjalankan pekerjaan sebenarnya, lalu mengumpan balik *output* agar model dapat menulis jawaban akhir:

import json

# Tambahkan giliran asisten yang meminta alat, lalu hasil alat.
messages.append(first.choices[0].message)
messages.append({
    "role": "tool",
    "tool_call_id": tool_call.id,
    "content": json.dumps({"city": "Singapore", "temp_c": 31, "sky": "humid"}),
})

final = client.chat.completions.create(model="kimi-k3", messages=messages, tools=tools)
print(final.choices[0].message.content)

Atur `tool_choice="required"` untuk memaksa panggilan alat, atau teruskan objek spesifik `{"type": "function", "function": {"name": "get_weather"}}` untuk mengunci satu fungsi. Batasan tersebut menjaga agen tetap pada jalurnya ketika Anda sudah tahu alat mana yang harus diaktifkan.

Satu *gotcha* khusus K3 yang patut diketahui lebih awal: model dilatih dalam mode riwayat pemikiran yang dipertahankan. Jika *harness* agen Anda menghilangkan penalaran model sebelumnya di antara giliran, kualitas generasi dapat menjadi tidak stabil. Saat Anda membangun *loop* agen multi-giliran, teruskan seluruh riwayat pesan kembali daripada memangkas giliran internal asisten.

Mode JSON dan *Output* Terstruktur

Ketika Anda membutuhkan *output* yang dapat dibaca mesin, minta JSON secara langsung daripada mengurai prosa. Atur `response_format` ke `json_object` dan instruksikan model untuk mengembalikan JSON.

response = client.chat.completions.create(
    model="kimi-k3",
    messages=[
        {"role": "system", "content": "Return only valid JSON. No prose, no markdown."},
        {"role": "user", "content": "Extract name and role from: 'Ada Lovelace, mathematician'."},
    ],
    response_format={"type": "json_object"},
)

print(response.choices[0].message.content)  # {"name": "Ada Lovelace", "role": "mathematician"}

Untuk jaminan yang lebih ketat, Kimi mendukung *output* terstruktur terhadap skema. Jika versi SDK Anda menerimanya, teruskan format respons `json_schema` agar model sesuai dengan bentuk Anda:

response = client.chat.completions.create(
    model="kimi-k3",
    messages=[{"role": "user", "content": "Extract name and role from: 'Ada Lovelace, mathematician'."}],
    response_format={
        "type": "json_schema",
        "json_schema": {
            "name": "person",
            "schema": {
                "type": "object",
                "properties": {
                    "name": {"type": "string"},
                    "role": {"type": "string"},
                },
                "required": ["name", "role"],
            },
        },
    },
)

Konfirmasi dukungan `json_schema` untuk akun Anda di konsol sebelum Anda mengimplementasikannya; jika ragu, `json_object` ditambah langkah validasi di pihak Anda adalah *fallback* yang aman. Kimi juga mengekspos mode parsial dan pencarian internet, yang membantu ketika Anda ingin mengisi respons asisten atau mendasarkan jawaban pada data baru.

Upaya Penalaran yang Dapat Dikonfigurasi

Kimi K3 mengekspos parameter `reasoning_effort` yang mengontrol seberapa banyak model berpikir sebelum menjawab. Saat ini level yang tersedia adalah `max`, yang juga merupakan *default*; Moonshot telah menyatakan bahwa level yang lebih rendah dan lebih tinggi direncanakan. Pemikiran yang lebih dalam membutuhkan lebih banyak token *output* dan menambah latensi, jadi ini adalah tuas yang Anda sesuaikan per tugas.

response = client.chat.completions.create(
    model="kimi-k3",
    messages=[{"role": "user", "content": "Plan a migration from REST to GraphQL for a 40-endpoint API."}],
    reasoning_effort="max",
)

Jika versi OpenAI SDK Anda menolak *field* tersebut sebagai tidak dikenal, teruskan melalui *escape hatch* sebagai gantinya:

response = client.chat.completions.create(
    model="kimi-k3",
    messages=[{"role": "user", "content": "Plan a migration from REST to GraphQL."}],
    extra_body={"reasoning_effort": "max"},
)

Pola `extra_body` adalah cara Anda mengirim *field* spesifik penyedia mana pun yang belum dimodelkan oleh SDK dasar, yang umum terjadi ketika *endpoint* yang kompatibel bergerak lebih cepat daripada pustaka klien.

Uji dan *Debug* kimi-k3 di Apidog

Kode SDK menyembunyikan format *wire* (jaringan), yang baik-baik saja hingga panggilan alat mengembalikan bentuk yang salah atau aliran terputus dan Anda tidak dapat mengetahui apakah kesalahannya ada pada Anda atau pada *endpoint*. Di sinilah klien API yang berbicara HTTP mentah membuahkan hasil. Apidog memungkinkan Anda mengirim permintaan `kimi-k3` yang tepat, menonton aliran SSE *frame* demi *frame*, dan menjaga kunci Anda keluar dari *body* permintaan. Jika Anda lebih suka menguji panggilan API tanpa berinteraksi dengan terminal, ini adalah *loop* yang lebih bersih daripada *curl-and-squint*; panduan pengujian API tanpa Postman mencakup alur kerja umum.

Berikut adalah *loop* terfokus untuk `kimi-k3`:

  1. Buat permintaan HTTP baru di Apidog. Atur metode ke POST dan URL ke URL dasar Anda ditambah `/chat/completions`.
  2. Simpan kunci Anda sebagai variabel lingkungan. Di pengaturan lingkungan Apidog, tambahkan `KIMI_API_KEY`, lalu atur *header* `Authorization` ke `Bearer {{KIMI_API_KEY}}`. Sekarang rahasia direferensikan, bukan ditempelkan, dan Anda dapat beralih antara kunci pengujian dan produksi dengan beralih lingkungan.
  3. Tempelkan *body* JSON dengan `"model": "kimi-k3"` dan *array* `messages` Anda. Kirim dan baca respons lengkapnya, termasuk penggunaan token, sehingga Anda dapat melihat jumlah *cache-hit* versus *cache-miss* pada panggilan nyata.
  4. Ubah `"stream": true` dan saksikan *server-sent events* tiba sebagai *frame* terpisah. Melihat potongan `data:` mentah membuat *bug streaming* jelas terlihat, tidak seperti cara *iterator* rapi SDK.
  5. *Debug* panggilan alat (*tool calls*) dengan memeriksa *array* `tool_calls` dalam respons. Ketika argumen kembali salah format, Anda dapat melihat apakah model menghasilkan JSON yang buruk atau skema Anda ambigu, dan memperbaiki deskripsinya di sana.
  6. Lakukan A/B terhadap `kimi-k2-7-code`. Duplikasi permintaan, ubah hanya *field* `model`, dan bandingkan latensi, kualitas *output*, dan biaya pada *prompt* yang sama. Itu adalah cara jujur tercepat untuk memutuskan apakah penalaran ekstra K3 sepadan dengan kenaikan harga untuk tugas Anda.

Karena Apidog mengimpor permintaan yang kompatibel dengan OpenAI secara langsung, Anda dapat menempelkan perintah cURL dan mendapatkan permintaan yang tersimpan, dapat diputar ulang dengan *header* dan *body* yang sudah terisi. Dari sana, ini menjadi kasus uji bersama yang dapat dijalankan kembali oleh tim Anda setiap kali Kimi merilis pembaruan. Jika agen Anda berbicara dengan model melalui MCP, panduan *debugging* visual dengan klien Apidog MCP menunjukkan cara melacak panggilan tersebut juga. Unduh Apidog jika Anda ingin mengikuti *loop* ini dengan kunci Anda sendiri.

Kasus Penggunaan Dunia Nyata

Dalam setiap kasus ini, alur kerjanya sama: bangun permintaan dengan SDK, verifikasi perilaku mentah di Apidog, lalu integrasikan ke dalam aplikasi Anda setelah Anda memercayai bentuknya.

Kesimpulan

Memanggil Kimi K3 bermuara pada tiga pengaturan pada klien yang kompatibel dengan OpenAI: URL dasar dari konsol Anda, kunci API Anda, dan `model="kimi-k3"`. Dari sana, *streaming*, panggilan alat (*tool calls*), mode JSON, *output* terstruktur, dan `reasoning_effort` semuanya mengikuti kontrak *chat-completions* yang sudah Anda ketahui. Dua hal yang patut dipahami adalah ekonomi *caching*, di mana menjaga prefiks stabil mengubah *input* $3.00 menjadi *input* $0.30, dan pertukaran jujur bahwa K3 membeli kedalaman penalaran dengan harga yang nyata, jadi arahkan pekerjaan rutin bervolume tinggi ke lini K2.7. Bangun permintaan dalam kode, buktikan di Apidog, dan Anda akan meluncurkan `kimi-k3` tanpa kejutan.

FAQ

Mengembangkan API dengan Apidog

Apidog adalah alat pengembangan API yang membantu Anda mengembangkan API dengan lebih mudah dan efisien.

Daftar gratisUnduh