Blog

Cara Menggunakan API Kimi K2.6

Ashley Innocent

Ashley Innocent

21 April 2026

Cara Menggunakan API Kimi K2.6

Apidog untuk Perusahaan

Penerapan On-Premises

SSO & RBAC

Sesuai SOC 2

Jelajahi Apidog Enterprise

Pengumuman Kimi K2.6 dari Moonshot AI menempatkannya sebagai teknologi mutakhir sumber terbuka yang baru untuk pemrograman, eksekusi jangka panjang, dan kelompok agen (agent swarms). API yang mendukungnya kompatibel dengan OpenAI, di-host di https://api.moonshot.ai/v1, dan didokumentasikan di platform. Jika Anda memiliki SDK OpenAI yang terinstal, Anda dapat mengirim permintaan nyata dalam waktu sekitar lima menit.

Panduan ini akan membahas autentikasi, permintaan pertama Anda, streaming, pemanggilan alat, input visi dan video, mode berpikir, dan cara mengoperasikan Agent Swarm dengan 300 sub-agen, serta menunjukkan cara menguji setiap *endpoint* dengan Apidog sebelum Anda menulis kode integrasi.

💡
Jalur cepat: Uji API Kimi K2.6 secara visual di Apidog sebelum melakukan *commit* kode integrasi apa pun. Satu impor, satu token Bearer, dan Anda membuat permintaan *stream* nyata dengan riwayat lengkap dan validasi skema. Unduh Apidog secara gratis.
tombol

TL;DR: API Kimi K2.6 dalam 60 Detik

curl minimal:

curl https://api.moonshot.ai/v1/chat/completions \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $KIMI_API_KEY" \
  -d '{
    "model": "kimi-k2.6",
    "messages": [{"role": "user", "content": "Write a Python function that reverses a string."}]
  }'

Itu saja. Sisa panduan ini akan mengisi detailnya, termasuk Agent Swarm dan batas eksekusi 4.000 langkah yang disebut Moonshot.

Apa yang benar-benar bisa Anda lakukan dengan API ini

Dari pengumuman Kimi K2.6, API ini membuka semua hal berikut dalam produksi:

Jika Anda membangun alat dalam kategori yang sama dengan penggunaan komputer Claude Code, bangun Claude Code Anda sendiri, atau Cursor Composer 2, API K2.6 adalah pengganti langsung pada lapisan model.

Langkah 1: Dapatkan Kunci API

  1. Buka platform.moonshot.ai (atau platform.kimi.ai) dan daftar. Email atau Google OAuth bisa digunakan.
  2. Verifikasi akun Anda. Pengguna internasional mungkin memerlukan verifikasi SMS.
  3. Tambahkan pembayaran. Moonshot biasanya memberikan kredit kecil gratis kepada akun baru.
  4. Buka Kunci API di *dashboard* dan klik Buat Kunci.
  5. Salin kuncinya segera (hanya ditampilkan sekali).
  6. Ekspor:
export KIMI_API_KEY="sk-..."

Tambahkan ke .zshrc, .bashrc, atau pengelola rahasia untuk produksi. Jangan pernah memasukkannya ke dalam *commit*.

Ingin menghindari pembayaran selama pengembangan? Cara Menggunakan Kimi K2.6 secara Gratis mencakup Cloudflare Workers AI, *weights* yang di-host sendiri, dan program kredit gratis.

Langkah 2: Pilih SDK Anda

API ini kompatibel dengan OpenAI, jadi SDK OpenAI resmi akan berfungsi setelah Anda mengubah URL dasar.

Pilihan Instalasi Terbaik untuk
curl bawaan Tes cepat, CI
OpenAI Python pip install openai Layanan Python
OpenAI Node npm install openai Aplikasi JS/TS

Python

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.getenv("KIMI_API_KEY"),
    base_url="https://api.moonshot.ai/v1",
)

response = client.chat.completions.create(
    model="kimi-k2.6",
    messages=[{"role": "user", "content": "What is the capital of France?"}],
)

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

Node.js

import OpenAI from "openai";

const client = new OpenAI({
  apiKey: process.env.KIMI_API_KEY,
  baseURL: "https://api.moonshot.ai/v1",
});

const response = await client.chat.completions.create({
  model: "kimi-k2.6",
  messages: [{ role: "user", content: "What is the capital of France?" }],
});

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

curl

curl https://api.moonshot.ai/v1/chat/completions \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $KIMI_API_KEY" \
  -d '{
    "model": "kimi-k2.6",
    "messages": [{"role": "user", "content": "What is the capital of France?"}]
  }'

Ketiganya mengembalikan bentuk respons yang sama.

Langkah 3: Pahami Isi Permintaan

Kolom yang sama dengan penyelesaian *chat* OpenAI:

{
  "model": "kimi-k2.6",
  "messages": [
    { "role": "system", "content": "You are a helpful assistant." },
    { "role": "user", "content": "Your prompt here." }
  ],
  "temperature": 1.0,
  "top_p": 1.0,
  "max_tokens": 8192,
  "stream": false,
  "tools": [],
  "tool_choice": "auto",
  "thinking": { "type": "disabled" }
}

Dua catatan khusus Moonshot:

Langkah 4: Streaming

Streaming adalah *default* yang tepat untuk UI atau generasi yang panjang. Output maksimum untuk tugas penalaran bisa mencapai 98.304 token; Anda tidak ingin menunggu semuanya sekaligus.

Python

stream = client.chat.completions.create(
    model="kimi-k2.6",
    messages=[{"role": "user", "content": "Write a 500-word essay on MoE models."}],
    stream=True,
)

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

Node.js

const stream = await client.chat.completions.create({
  model: "kimi-k2.6",
  messages: [{ role: "user", content: "Write a 500-word essay on MoE models." }],
  stream: true,
});

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

Streaming juga berfungsi dengan panggilan alat; argumen tiba sebagai *delta* JSON yang Anda gabungkan.

Langkah 5: Pemanggilan Alat

Moonshot melaporkan skor Toolathlon 50.0% dan tingkat keberhasilan pemanggilan alat 96.60% dalam pengujian mitra. Formatnya adalah skema pemanggilan fungsi standar OpenAI, sehingga alur kerja pengujian API yang ada untuk insinyur QA berlaku.

Definisikan Alat

tools = [
    {
        "type": "function",
        "function": {
            "name": "get_weather",
            "description": "Get the current weather in a location.",
            "parameters": {
                "type": "object",
                "properties": {
                    "location": {"type": "string", "description": "City name"},
                    "unit": {"type": "string", "enum": ["celsius", "fahrenheit"]}
                },
                "required": ["location"]
            }
        }
    }
]

Panggilan Pertama (model memutuskan)

import json

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

resp = client.chat.completions.create(
    model="kimi-k2.6",
    messages=messages,
    tools=tools,
    tool_choice="auto",
)

msg = resp.choices[0].message
messages.append(msg)

if msg.tool_calls:
    for call in msg.tool_calls:
        args = json.loads(call.function.arguments)
        result = fetch_weather(args["location"], args.get("unit", "celsius"))
        messages.append({
            "role": "tool",
            "tool_call_id": call.id,
            "content": json.dumps(result),
        })

Panggilan Kedua (jawaban akhir)

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

K2.6 sangat kuat dalam rantai alat multi-langkah, yang membuat agen pemrograman yang berjalan lama seperti Kimi Code menjadi mungkin. Untuk perbandingan *framework*, alur kerja Claude Code mencakup *loop* yang sama dengan *backend* yang berbeda.

Langkah 6: Input Visi

K2.6 mencetak 79.4% pada MMMU-Pro dan 96.9% pada V* (dengan Python). Gambar masuk ke pesan pengguna menggunakan format konten image_url OpenAI:

response = client.chat.completions.create(
    model="kimi-k2.6",
    messages=[
        {
            "role": "user",
            "content": [
                {"type": "text", "text": "Describe this image in one sentence."},
                {"type": "image_url", "image_url": {"url": "https://example.com/photo.jpg"}}
            ]
        }
    ],
)

Untuk file lokal, *encode* dengan base64:

import base64
with open("photo.jpg", "rb") as f:
    b64 = base64.b64encode(f.read()).decode("utf-8")

image_url = f"data:image/jpeg;base64,{b64}"

Untuk OCR atau pembacaan diagram, gabungkan instruksi teks yang jelas dengan gambar. Untuk masalah matematika, sertakan alat penerjemah Python; skor MathVision 93.2% diukur dengan akses Python diaktifkan.

Langkah 7: Input Video

Teruskan URL video atau urutan *frame*:

response = client.chat.completions.create(
    model="kimi-k2.6",
    messages=[
        {
            "role": "user",
            "content": [
                {"type": "text", "text": "Summarize what happens in this video."},
                {"type": "video_url", "video_url": {"url": "https://example.com/clip.mp4"}}
            ]
        }
    ],
)

Klip pendek (<30 detik) berfungsi dalam satu panggilan. Video yang lebih panjang mendapatkan manfaat dari streaming karena inferensi *frame-by-frame* menghasilkan banyak token.

Langkah 8: Mode Berpikir

kimi-k2.6-thinking menghasilkan jejak penalaran yang terlihat (mirip dengan model gaya o1 OpenAI). Moonshot melaporkan 96.4% pada AIME 2026 dan 90.5% pada GPQA-Diamond dengan mode berpikir diaktifkan.

Mode berpikir aktif (default untuk model berpikir):

response = client.chat.completions.create(
    model="kimi-k2.6-thinking",
    messages=[{"role": "user", "content": "Prove sqrt(2) is irrational."}],
)

Mode berpikir nonaktif:

response = client.chat.completions.create(
    model="kimi-k2.6-thinking",
    messages=[{"role": "user", "content": "Quick: what's 17 * 23?"}],
    extra_body={"thinking": {"type": "disabled"}},
)

Jejak penalaran dikembalikan dalam bidang reasoning pada respons. Anda dapat menyembunyikannya dari pengguna akhir dan hanya menampilkan jawaban akhir, atau memasukkannya ke dalam log debug.

Langkah 9: Kelompok Agen (Agent Swarm)

Agent Swarm adalah fitur yang paling layak dipelajari. Dari blog Kimi K2.6: hingga 300 sub-agen, 4.000+ langkah terkoordinasi, 3x kapasitas K2.5.

Aktifkan melalui parameter agen platform:

response = client.chat.completions.create(
    model="kimi-k2.6",
    messages=[{
        "role": "user",
        "content": "Build a 5-page marketing site for a coffee brand with responsive design and a newsletter signup."
    }],
    extra_body={
        "agent": {
            "type": "swarm",
            "max_agents": 30,
            "max_steps": 4000
        }
    },
)

Panggilan Swarm berjalan selama beberapa menit atau jam. Tiga tips praktis:

  1. Gunakan streaming. Anda pasti ingin melihat kemajuan dan menghentikan proses yang buruk lebih awal.
  2. Batasi max_agents. 300 adalah batas maksimum; 10 hingga 30 lebih dapat diprediksi untuk sebagian besar tugas.
  3. Tetapkan anggaran. Tugas swarm yang panjang dapat menghabiskan token dengan cepat; catat usage pada setiap respons dan masukkan ke dalam metrik Anda.

Blog Kimi menjelaskan demo berjalan yang memodifikasi 4.000+ baris kode selama 13 jam. Arsitekturnya yang memungkinkan hal tersebut; *flag* API hanya mengaktifkannya.

Langkah 10: Uji Segala Sesuatu dengan Apidog

Setiap bagian di atas memperkenalkan bentuk *body*, persyaratan *header*, atau format respons yang berbeda. Apidog mengubah *loop debugging* menjadi alur kerja visual.

Pengaturan Kimi K2.6 di Apidog

  1. Unduh Apidog dan buat proyek.
  2. Buat lingkungan kimi-prod dengan dua variabel: BASE_URL = https://api.moonshot.ai/v1 dan KIMI_API_KEY = sk-....
  3. Permintaan API baru: POST {{BASE_URL}}/chat/completions.
  4. Header: Authorization: Bearer {{KIMI_API_KEY}}, Content-Type: application/json.
  5. Isi (contoh streaming):
{
  "model": "kimi-k2.6",
  "messages": [{ "role": "user", "content": "Hello, Kimi K2.6!" }],
  "stream": true
}
  1. Klik Kirim. Token akan mengalir ke panel respons secara *real time*.

Apa yang Ditambahkan Apidog

Untuk pengujian dalam editor, Apidog juga tersedia sebagai ekstensi VS Code. Jika Anda saat ini terkunci di Postman, cara melakukan pengujian API tanpa Postman menjelaskan langkah-langkah perpindahannya.

Penanganan Kesalahan yang Tidak Akan Menyulitkan Anda

Moonshot menggunakan kode status HTTP standar:

Pembungkus coba ulang:

import time
from openai import OpenAI, RateLimitError, APIError

def call_kimi(messages, max_retries=5):
    for attempt in range(max_retries):
        try:
            return client.chat.completions.create(
                model="kimi-k2.6",
                messages=messages,
            )
        except RateLimitError:
            time.sleep(2 ** attempt)
        except APIError as e:
            if e.status_code >= 500 and attempt < max_retries - 1:
                time.sleep(2 ** attempt)
            else:
                raise
    raise RuntimeError("Kimi K2.6 failed after retries")

Untuk pemutusan di tengah *stream*, lacak token yang diterima dan mulai ulang dengan instruksi "lanjutkan dari sini" jika koneksi terputus. Batas output penalaran 98.304 token berarti *stream* yang panjang adalah normal, bukan kesalahan.

Pengendalian Biaya

Moonshot mempublikasikan harga di kimi.com/membership/pricing. Tiga tips tingkat produksi untuk menjaga tagihan tetap dapat diprediksi:

Pola Produksi: Perbaikan Masalah GitHub

Berikut adalah agen yang membaca masalah GitHub, menemukan kode yang relevan, mengusulkan perbaikan, dan menjalankan tes, terstruktur di sekitar *loop* pemanggilan alat Kimi K2.6:

from openai import OpenAI
import os, json

client = OpenAI(
    api_key=os.getenv("KIMI_API_KEY"),
    base_url="https://api.moonshot.ai/v1",
)

tools = [
    {"type": "function", "function": {
        "name": "read_file",
        "description": "Read a file in the repo.",
        "parameters": {
            "type": "object",
            "properties": {"path": {"type": "string"}},
            "required": ["path"]
        }
    }},
    {"type": "function", "function": {
        "name": "search_code",
        "description": "Ripgrep the codebase for a pattern.",
        "parameters": {
            "type": "object",
            "properties": {"query": {"type": "string"}},
            "required": ["query"]
        }
    }},
    {"type": "function", "function": {
        "name": "run_tests",
        "description": "Run the project test suite.",
        "parameters": {"type": "object", "properties": {}}
    }},
]

def tool_dispatch(name, args):
    if name == "read_file":
        with open(args["path"]) as f:
            return f.read()
    if name == "search_code":
        return run_ripgrep(args["query"])
    if name == "run_tests":
        return run_pytest()
    raise ValueError(f"Unknown tool: {name}")

messages = [
    {"role": "system", "content": "You are a senior engineer. Fix the described bug."},
    {"role": "user", "content": "Issue: login form submits twice on slow networks."}
]

while True:
    resp = client.chat.completions.create(
        model="kimi-k2.6",
        messages=messages,
        tools=tools,
    )
    msg = resp.choices[0].message
    messages.append(msg)

    if not msg.tool_calls:
        print(msg.content)
        break

    for call in msg.tool_calls:
        result = tool_dispatch(call.function.name, json.loads(call.function.arguments))
        messages.append({
            "role": "tool",
            "tool_call_id": call.id,
            "content": result,
        })

Ini dapat ditingkatkan ke Agent Swarm dengan menambahkan konfigurasi swarm extra_body. Ini juga berfungsi baik dengan tumpukan *multi-agent* Hermes jika Anda menginginkan *checkpoint human-in-the-loop*.

FAQ

Apakah saya memerlukan SDK khusus Moonshot?Tidak. SDK OpenAI Python dan Node akan berfungsi setelah Anda mengubah base_url.

Apakah API memiliki batas *rate*?Ya. Batas akan menyesuaikan dengan tingkatan dan riwayat penggunaan Anda. Periksa *dashboard*.

Apakah Kimi K2.6 berfungsi dengan LangChain, LlamaIndex, Vercel AI SDK?Ya. *Framework* apa pun yang menerima URL dasar yang kompatibel dengan OpenAI akan berfungsi.

Apakah Kimi K2.6 mendukung mode JSON?Ya. Teruskan response_format: {"type": "json_object"} untuk output JSON yang valid, atau {"type": "json_schema", "json_schema": {...}} untuk skema yang ketat.

Seberapa besar jendela konteksnya, tepatnya?262.144 token input, 98.304 token output maksimum untuk tugas penalaran, sesuai blog resmi.

Dapatkah saya melakukan *fine-tuning* Kimi K2.6 melalui API?Belum. Untuk saat ini, *fine-tuning* berarti menjalankan *weights* sumber terbuka di perangkat keras Anda sendiri.

Apa perbedaan antara kimi-k2.6 dan kimi-k2.6-thinking?kimi-k2.6 adalah model agen cepat. kimi-k2.6-thinking mengekspos langkah-langkah penalaran dan disetel untuk matematika, logika, dan perencanaan yang sulit (AIME 2026: 96.4%, GPQA-Diamond: 90.5%).

Apakah ada tingkatan gratis?Lihat panduan akses gratis Kimi K2.6 kami untuk Cloudflare Workers AI, obrolan kimi.com, dan opsi *self-hosted*.

Ringkasan

API Kimi K2.6 dapat diintegrasikan ke dalam *toolchain* yang kompatibel dengan OpenAI dengan dua perubahan: URL dasar dan kunci API Anda. Dari sana Anda mendapatkan jendela konteks 262K, Agent Swarm dengan 300 sub-agen, pemanggilan alat yang disetel untuk keberhasilan pemanggilan 96.60%, dan *weights* sumber terbuka sebagai *fallback* jika Anda ingin beralih dari API yang di-host.

Jika Anda membangun integrasi baru, gunakan Apidog untuk membangun dan memverifikasi setiap *endpoint* terlebih dahulu. Anda akan menemukan kesalahan skema, *bug* *streaming*, dan masalah otentikasi sebelum masuk ke *codebase* Anda. Kemudian *porting* permintaan yang berfungsi ke layanan Python atau Node Anda dengan percaya diri.

Referensi dan Bacaan Lebih Lanjut

Mengembangkan API dengan Apidog

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

Daftar gratisUnduh