TL;DR Moonshot AI priser for øyeblikket Kimi K2.7 Code til $0.19 per 1M cache-treff-inndata, $0.95 per 1M cache-bom-inndata og $4.00 per 1M utdata. Kimi K2.7 Code HighSpeed dobler disse satsene til $0.38 / $1.90 / $8.00.
De viktigste kostnadshensynene er:
- Caching: K2.7 cache-treff-inndata hos Moonshot er 80% billigere enn cache-bom-inndata.
- HighSpeed: Den raskere ruten koster dobbelt så mye per token.
- Batch API: Støttede modeller koster 60% av sanntidsprisene, tilsvarende 40% besparelse.
- WebSearch: Moonshot tar $0.005 per vellykket innebygd søkeanrop, i tillegg til tokenene som brukes til å prosessere søkeresultater.
- Kompatibilitet: K2.7 Code krever Thinking, mens Moonshots innebygde WebSearch krever at Thinking er deaktivert.
For kodeagenter er den mest nyttige metrikken ikke pris per million tokens. Det er kostnad per fullført oppgave, inkludert resonnering, caching, retries, verktøyanrop, ventetid og menneskelige korrigeringer.
Kimi K2 API-priser i et blikk
kilde: Kimi K2.7 Code pricing
| Modell eller rute | Cache-treff (inndata) | Cache-bom eller standard inndata | Utdata | Kontekst |
|---|---|---|---|---|
| Moonshot K2.7 Code | $0.19 / 1M | $0.95 / 1M | $4.00 / 1M | 256K |
| Moonshot K2.7 Code HighSpeed | $0.38 / 1M | $1.90 / 1M | $8.00 / 1M | 256K |
| Moonshot K2.6 | $0.16 / 1M | $0.95 / 1M | $4.00 / 1M | 256K |
| Moonshot K2.5 | $0.10 / 1M | $0.60 / 1M | $3.00 / 1M | 256K |
| CometAPI K2.7 Code | Ikke oppført separat | $0.76 / 1M | Ca. $3.20 / 1M | 256K |
K2.7-prisene hos Moonshot er for tiden kampanjepriser. Moonshot og CometAPI bruker også forskjellige faktureringsstrukturer for inndata, så listede satser bør ikke betraktes som direkte utskiftbare.
Moonshot Kimi K2-priser forklart
K2.7 Code og K2.6 deler samme cache-bom-inndata- og utdata-priser. De viktigste token-nivåforskjellene er at K2.7 Code tar litt mer for bufret inndata, mens HighSpeed dobler alle K2.7-satser.
| Modell | Best egnet for |
|---|---|
| kimi-k2.7-code | Kodeagenter, repository-endringer og langhorizonteringstekniske oppgaver |
| kimi-k2.7-code-highspeed | Interaktiv koding der lavere ventetid har målbar verdi |
| kimi-k2.6 | Generell multimodal resonnering, agenter og innebygd WebSearch |
| kimi-k2.5 | Rimeligere generelle og multimodale arbeidsmengder |
Moonshot beskriver HighSpeed som samme underliggende K2.7 Code-modell levert via en raskere rute. Dokumentert utdatahastighet er omtrent 180 tokens per sekund, opp til 260 tokens per sekund i kortere kontekster. Kapasiteten kan variere mens Moonshot utvider ressursene.
HighSpeed er derfor primært et latency-valg fremfor et eget kvalitetsnivå for modellen.
Et Moonshot Direct API-alternativ: CometAPI
Utviklere kan få tilgang til Kimi K2.7 Code direkte via Moonshot AI eller via CometAPIs OpenAI-kompatible API.
| Tilgangsrute | Standard inndata | Bufret inndata | Utdata |
|---|---|---|---|
| Moonshot direct API | $0.95 / 1M cache-bom | $0.19 / 1M | $4.00 / 1M |
| CometAPI | $0.76 / 1M | Ikke oppført separat | Ca. $3.20 / 1M |
CometAPIs oppførte standard inndata- og utdata-priser er omtrent 20% lavere, mens Moonshot kan være mer kostnadseffektivt for arbeidslaster med høy cache-treff-rate.
Velg CometAPI hvis du ønsker én API for Kimi og andre modellleverandører. Velg direkte tilgang hos Moonshot hvis arbeidsflyten ofte gjenbruker de samme promptene eller repository-konteksten.
kilde: Kimi K2.7 Code price on CometAPI
Med dagens oppførte satser er CometAPI omtrent 20% billigere enn Moonshots cache-bom-inndata- og utdata-priser.
CometAPI viser imidlertid ikke en egen cache-treff-pris på modellsiden. Deres $0.76 standard inndata-pris bør ikke sammenlignes direkte med Moonshots $0.19 for bufret inndata.
Team som gjentatte ganger gjenbruker lange systemprompter, verktøydefinisjoner eller repository-kontekst bør teste begge rutene med faktisk trafikk. En arbeidsmengde med svært høy cache-treff-rate kan gi et annet resultat enn en som stort sett sender ny kontekst.
Se den nyeste Kimi K2.7 Code price on CometAPI eller sammenlign tilgjengelige modeller på CometAPI pricing page.
Hvordan kontekstbufring endrer Kimi API-kostnad
Kimi fakturerer inndata-tokens som cache-treff eller cache-bom.
Cache-bom inkluderer vanligvis nytt eller endret innhold, for eksempel:
- nye repository-filer
- oppdaterte instrukser
- ferske verktøyresultater
- endret samtalehistorikk
Cache-treff kan inkludere gjentatt innhold, som stabile systemprompter, verktøyskjemaer, kodestandarder og uendret repository-kontekst.
For K2.7 Code koster bufret inndata $0.19 per 1M tokens sammenlignet med $0.95 for ubufret inndata. Det gjør et cache-treff-token 80% billigere.
Beregn de to kategoriene separat:
Input cost =
(cache-hit tokens ÷ 1,000,000 × cache-hit price)
+
(cache-miss tokens ÷ 1,000,000 × cache-miss price)
Eksempel på caching-kostnad
Anta én arbeidsflytprosess:
- 800,000 cache-treff-tokens
- 200,000 cache-bom-tokens
| Token-kategori | Beregning | Kostnad |
|---|---|---|
| Cache-treff | 800,000 ÷ 1M × $0.19 | $0.15 |
| Cache-bom | 200,000 ÷ 1M × $0.95 | $0.19 |
| Total inndata-kostnad | $0.152 + $0.190 | $0.34 |
Å beregne de samme 1M tokenene helt til cache-bom-sats ville kostet $0.95. I dette eksempelet reduserer den blandede cache-profilen inndata-kostnaden med $0.608.
Derfor bør produksjonsdashbord registrere cache-treff- og cache-bom-tokens separat i stedet for å rapportere bare total inndata-bruk.
Kimi Batch API-priser
Moonshots Batch API belaster 60% av tilsvarende sanntidsmodellpris, noe som gir team 40% besparelse på støttede asynkrone arbeidsmengder. Dagens dokumentasjon lister K2.7 Code, K2.6 og K2.5 som støttede Batch-modeller.
| Batch-modell | Cache-treff inndata | Cache-bom inndata | Utdata |
|---|---|---|---|
| kimi-k2.7-code | $0.114 / 1M | $0.57 / 1M | $2.40 / 1M |
| kimi-k2.6 | $0.096 / 1M | $0.57 / 1M | $2.40 / 1M |
| kimi-k2.5 | $0.06 / 1M | $0.36 / 1M | $1.80 / 1M |
Batch API passer godt for:
- repository-omfattende kodeanalyse
- store evalueringskjøringer
- offline-klassifisering
- nattlig beriking
- syntetisk testgenerering
- migrasjonsanalyse
- sikkerhetsgjennomgangs-oppgaver i backlog
Det er mindre egnet for IDE-assistenter, live chat og andre arbeidsflyter der en bruker venter på et umiddelbart svar.
For bakgrunnsprosessering kan 40% besparelse være mer verdifull enn å bytte til en billigere modell med lavere oppgavefullføringsrate.
Kimi WebSearch-priser og kompatibilitet
Moonshot tar $0.005 for hver vellykket innebygd $web_search -anrop. Ingen separat verktøyavgift belastes når modellen avslutter uten å trigge søkeverktøyet.
Innhold fra søkeresultater kan også legges til neste modellforespørsel og faktureres som inndata-tokens. Moonshot definerer den resulterende tokentellingen som:
Total tokens =
prompt tokens + search-result tokens + completion tokens
En komplett søkearbeidsflyt kan derfor inkludere:
Initial model request
+ WebSearch tool fee
+ search-result input tokens
+ follow-up model request
+ retries
Det er også en viktig modellbegrensning. Moonshots innebygde WebSearch krever at Thinking er deaktivert, mens K2.7 Code ikke støtter non-thinking-modus. Det offisielle WebSearch-eksempelet bruker derfor K2.6 med Thinking deaktivert.
For Moonshots innebygde søk, bruk K2.6 eller K2.5 med Thinking deaktivert.
En K2.7-kodeagent kan fortsatt kalle en separat implementert søketjeneste via vanlige funksjonskall. I så fall bestemmes søkeprisen av ekstern leverandør i stedet for Moonshots $0.005 innebygde avgift.
Eksempel 1: K2.7 Code-kostnad for en kodeoppgave
Anta at en kodeagent-arbeidsflyt bruker:
- 30,000 cache-bom inndata-tokens
- 8,000 utdata-tokens, inkludert resonnering
- ingen innebygd WebSearch-anrop
Standard K2.7 Code
| Komponent | Beregning | Kostnad |
|---|---|---|
| Inndata | 30,000 ÷ 1M × $0.95 | $0.03 |
| Utdata | 8,000 ÷ 1M × $4.00 | $0.03 |
| Totalt | $0.06 |
K2.7 Code HighSpeed
| Komponent | Beregning | Kostnad |
|---|---|---|
| Inndata | 30,000 ÷ 1M × $1.90 | $0.06 |
| Utdata | 8,000 ÷ 1M × $8.00 | $0.06 |
| Totalt | $0.12 |
For samme tokenbruk koster HighSpeed nøyaktig dobbelt så mye.
CometAPI K2.7 Code
Med dagens CometAPI-satser:
| Komponent | Beregning | Kostnad |
|---|---|---|
| Inndata | 30,000 ÷ 1M × $0.76 | $0.02 |
| Utdata | 8,000 ÷ 1M × $3.19998 | Ca. $0.0256 |
| Totalt | Ca. $0.0484 |
Det er omtrent 20% under Moonshots cache-bom tokenkostnad på $0.0605 i dette eksempelet. Beregningen utelater skatter, eksterne verktøy og andre plattformtjenester.
Eksempel 2: K2.6 med innebygd WebSearch
Anta at en K2.6-arbeidsflyt med Thinking deaktivert bruker:
- 30,000 cache-bom inndata-tokens gjennom hele arbeidsflyten
- 8,000 utdata-tokens
- ett vellykket innebygd WebSearch-anrop
De 30,000 inndata-tokenene inkluderer søkeresultatinnhold som tas med i oppfølgingsforespørselen.
| Komponent | Beregning | Kostnad |
|---|---|---|
| Inndata | 30,000 ÷ 1M × $0.95 | 0.0285 |
| Utdata | 8,000 ÷ 1M × $4.00 | 0.0320 |
| WebSearch | 1 × $0.005 | 0.0050 |
| Totalt | 0.0655 |
I dette eksempelet utgjør den direkte WebSearch-avgiften omtrent 7.6% av totalen. I lengre forskningsarbeidsflyter kan tokenene som tilføres av søkeresultater koste mer enn selve verktøyanropet.
Tekniske detaljer som kan endre den endelige kostnaden
K2.7 Code bruker alltid Thinking-modus
Kilde:* KIMI Thinking Mode Documentation
K2.7 Code returnerer en feil hvis Thinking er deaktivert. Dets resonnering returneres gjennom reasoning_content, og både resonnering og det synlige svaret bidrar til tokenbruk.
Under flertrinns verktøykall må applikasjoner bevare assistentens reasoning_content i samtalekonteksten. Lengre agentløkker kan derfor øke både nåværende utdata-bruk og senere inndata-bruk.
max_tokens er en grense, ikke en fast avgift
Parameteren max_tokens definerer maksimum modellen kan generere. En høyere innstilling gir modellen nok rom til å fullføre resonnering og svar, men hele kvoten blir ikke automatisk fakturert.
Kostnader er basert på faktiske tokens som behandles og genereres.
Flere forespørselsparametere er faste
K2.7 Code krever faste verdier for flere parametere:
| Parameter | Påkrevd verdi |
|---|---|
| temperature | 1 |
| top_p | 0.95 |
| n | 1 |
| presence_penalty | 0 |
| frequency_penalty | 0 |
Å sende en annen verdi kan gi en feil. Applikasjoner som bruker samme OpenAI-kompatible wrapper på tvers av flere leverandører bør inspisere hardkodede standarder før de bytter modeller.
For en praktisk integrasjonsveiledning, se How to Use Kimi K2.7 Code API with CometAPI.
Ekstern adopsjon og utviklersignaler
Offisiell prismarkedsføring forklarer hvordan modellen blir fakturert. Ekstern adopsjon gir ekstra kontekst om hvor den brukes og hvordan utviklere evaluerer den.
GitHub Copilot
GitHub gjorde Kimi K2.7 Code allment tilgjengelig i Copilot 1. juli 2026, og beskrev den som den første open-weight-modellen som tilbys i Copilots modellvelger. Tilgjengeligheten dekket først individuelle planer og ble utvidet til Business- og Enterprise-planer 7. juli.
GitHubs adopsjon er et nyttig distribusjonssignal, men det beviser ikke at K2.7 vil overgå andre modeller på alle kodearbeidslaster.
Eksterne kilder:
- Kimi K2.7 Code is generally available in GitHub Copilot
- Kimi K2.7 for Copilot Business and Enterprise
Open-weight-distribusjonsøkosystem
Moonshot publiserer Kimi K2.7 Code på Hugging Face under en modifisert MIT-lisens. Modelkortet beskriver en Mixture-of-Experts-arkitektur med 1 billion parametere, 32 milliarder aktiverte parametere og et 256K kontekstvindu. Det inkluderer også distribusjonsinstruksjoner for rammeverk som Transformers, vLLM og SGLang.
Moonshot rapporterer omtrent 30% lavere thinking-token-bruk enn K2.6 og 10% forbedring i agentiske kapabiliteter. Dette er leverandørrapporterte resultater og bør valideres med uavhengige arbeidslaster.
Se Kimi K2.7 Code model card on Hugging Face for arkitektur- og distribusjonsdetaljer.
Diskusjon i utviklermiljøet
Diskusjonen på Hacker News er mer blandet enn lanseringsmaterialet. Noen utviklere fokuserer på Kimis open-weight-tilgjengelighet, tokeneffektivitet og integrasjon med kodeagent-verktøy. Andre hevder at lavere tokenpris ikke garanterer lavere prosjektkostnad hvis modellen krever flere retries, tilsyn eller kontekst.
Den debatten støtter hovedanbefalingen i denne guiden: sammenlign modeller ved hjelp av ekte repositories og mål oppgavefullføring, retries og menneskelige redigeringer—ikke bare annonserte tokenrater.
Se Kimi K2.7 Code discussion on Hacker News.
GPT vs Claude vs Kimi vs DeepSeek API-prising
Tabellen nedenfor sammenligner nåværende standard API-satser for Kimi K2.7 Code, DeepSeek V4 Pro, Claude Sonnet 5 og GPT-5.6 Sol per 13. juli 2026.
| Leverandør | Modell | Standard inndata | Bufret inndata eller lesing | Utdata | Merknader | CometAPI-pris |
|---|---|---|---|---|---|---|
| Moonshot AI | Kimi K2.7 Code | $0.95 / 1M | $0.19 / 1M | $4.00 / 1M | Kampanjepriser | $0.76 inndata / ~$3.20 utdata |
| DeepSeek | DeepSeek V4 Pro | $0.435 / 1M cache-bom | $0.003625 / 1M | $0.87 / 1M | 1M kontekst | $0.416 inndata / $0.832 utdata |
| Anthropic | Claude Sonnet 5 | $2.00 / 1M | $0.20 / 1M cache-lesing | $10.00 / 1M | Intropriser til 31. aug. 2026 | $1.60 inndata / $8.00 utdata |
| OpenAI | GPT-5.6 Sol | $5.00 / 1M | $0.50 / 1M | $30.00 / 1M | Standard kort-kontekst-prising | $4.00 inndata / $24.00 utdata |
Offisielle prisreferanser:
DeepSeek V4 Pro oppgir for tiden et 1M kontekstvindu med cache-treff-inndata på $0.003625, cache-bom-inndata på $0.435 og utdata på $0.87 per million tokens.
Claude Sonnet 5s introduksjonspris er $2 per million inndata-tokens, $0.20 per million cache-lese-tokens og $10 per million utdata-tokens til 31. august 2026. Dets cache-skrivinger er priset separat, og Anthropic bemerker at modellens nyere tokenizer kan produsere flere tokens for samme tekst enn tidligere Claude-modeller.
GPT-5.6 Sols standard kortkontekst-sats er $5 per million inndata-tokens, $0.50 per million bufrede inndata-tokens og $30 per million utdata-tokens. OpenAI lister også egne satser for cache-skriving, lang kontekst, Batch, Flex og Priority.
Med de oppførte tokenratene er Kimi K2.7 Code rimeligere enn Claude Sonnet 5 og GPT-5.6 Sol, mens DeepSeek V4 Pro er billigere. Dette fastslår ikke hvilken modell som gir lavest kostnad for en spesifikk kodearbeidsflyt.
Hvilken Kimi-modell bør du bruke?
| Arbeidslast | Anbefalt utgangspunkt |
|---|---|
| Repository-endringer og lange kodeoppgaver | kimi-k2.7-code |
| Interaktiv koding der latency betyr noe | kimi-k2.7-code-highspeed |
| Generell multimodal resonnering og agenter | kimi-k2.6 |
| Moonshots innebygde WebSearch | kimi-k2.6 eller kimi-k2.5 med Thinking deaktivert |
| Rimeligere generelle arbeidsmengder | kimi-k2.5 |
| Offline-evalueringer og masseprosessering | Batch API |
K2.7 Code er det naturlige startpunktet for kvalitets-sensitive kodeoppgaver. HighSpeed er verdt å teste når raskere svar forbedrer utvikleropplevelsen, konvertering eller gjennomstrømning.
K2.6 er mer fleksibel for generelle multimodale og søkegrunnede arbeidsflyter, mens K2.5 har de laveste standard Kimi-tokenratene.
Hvordan evaluere den reelle kostnaden
Bygg et evalueringssett fra produksjonsoppgaver i stedet for å bare stole på offentlige benchmarks.
Nyttige testtilfeller inkluderer:
- repository-nivå funksjonsimplementering
- pull request-gjennomgang
- feilsøking og testgenerering
- langkontekst kodeanalyse
- flertrinns verktøyanrop
- søkestøttet utviklerstøtte
Følg med på:
- vellykket oppgavefullføring
- cache-treff-rate
- inndata- og utdata-tokens
- thinking-/resonnerings-tokenvolum
- verktøyanrop-suksess
- antall retries
- p50- og p95-latency
- menneskelige korrigeringer
- total arbeidsflytkostnad
Beregn:
Cost per completed task =
total workflow cost ÷ successfully completed tasks
For eksempel, hvis et team bruker $10 og fullfører 80 oppgaver:
Cost per completed task = $10 ÷ 80 = $0.125
En modell med billigere tokens kan likevel koste mer hvis den krever gjentatte forsøk, lengre resonnering eller omfattende manuell korreksjon.
For eksempler på ruting, fallback og evaluering, se CometAPI Cookbook.
Ofte stilte spørsmål
Hvor mye koster Kimi K2.7 Code?
Moonshot oppgir for tiden K2.7 Code til:
- $0.19 per 1M cache-treff-inndata
- $0.95 per 1M cache-bom-inndata
- $4.00 per 1M utdata
Satsene er for tiden merket som kampanjepriser.
Hvor mye koster K2.7 Code via CometAPI?
CometAPI oppgir for tiden K2.7 Code til $0.76 per 1M inndata-tokens og $3.19998 per 1M utdata-tokens.
En separat cache-treff-sats vises ikke på modellsiden.
Reduserer Kimi Batch API kostnadene, og støtter det K2.7 Code?
Ja. Batch-inferens koster 60% av sanntidsprisen, tilsvarende 40% besparelse.
Moonshots nåværende Batch-dokumentasjon lister K2.7 Code, K2.6 og K2.5 som støttede modeller.
Hvor mye koster Kimi WebSearch?
Moonshots innebygde $web_search koster $0.005 per vellykket anrop.
Søkeresultatinnhold kan også bli fakturert som inndata-tokens når det inkluderes i neste modellforespørsel.
Kan Thinking deaktiveres på K2.7 Code?
Nei. Forespørsler som deaktiverer Thinking returnerer en feil.
Er Kimi OpenAI-kompatibel?
Ja. Moonshot dokumenterer kompatibilitet med OpenAI API-formatet, selv om modellspesifikke begrensninger fortsatt gjelder for Thinking, parametere og flertrinns verktøyanrop.
Test Kimi K2.7 Code med CometAPI
Kimi K2.7 Code tilbyr konkurransedyktige priser for kodeagent-arbeidslaster, men den beste ruten avhenger av mer enn oppgitt tokenrate.
Før du velger en leverandør, sammenlign:
Total workflow cost =
tokens + retries + tools + latency + human correction
CometAPI lar utviklere teste Kimi sammen med GPT, Claude, Gemini, DeepSeek, Grok og andre modellfamilier gjennom en enhetlig API-arbeidsflyt.
Se de nyeste CometAPI pricing, åpne Kimi K2.7 Code model page, og benchmark modellen med ekte oppgaver fra egne repositories.
Målet er ikke bare å finne den billigste tokenen. Det er å finne lavest kostnad per fullført oppgave.