Kimi K3.1 Pro: API pricing, speed and coding results

At November 2026 prices, Kimi K3.1 Pro costs $2 per million regular input tokens and $10 per million output tokens on Moonshot's API. Requesty's coding benchmark gives it an 81% solve rate, against 92% for Claude Opus 5.5 and 67% for GLM-5.3. Highspeed doubles the regular input and output prices on Moonshot's API, and Moonshot says its output is approximately 2 to 3 times faster.

Cache mix sets K3.1 Pro's direct API cost

The table below shows Moonshot's direct API prices per million tokens, before tax. A cache read uses previously cached input, while a cache write stores input for reuse.

Moonshot lists a 1,048,576-token context window for both variants. Pro has flat token pricing across that window, according to Moonshot.

Through Requesty, moonshot/kimi-k3.1-pro lists at the same $2 input and $10 output per million tokens in our model catalog, and DeepInfra, Fireworks, Novita, Runware and Together serve it at that price too. Requesty charges 5% on top of model costs.

Costing one request on Moonshot's direct API

Take one illustrative request with 700,000 regular input tokens, 200,000 cached input tokens and 100,000 output tokens. Assume there are no cache writes on that request.

The direct Moonshot cost for Pro is (0.7 x $2) + (0.2 x $0.20) + (0.1 x $10) = $2.44. For Highspeed, the cost is (0.7 x $4) + (0.2 x $0.20) + (0.1 x $20) = $4.84.

That makes Highspeed $2.40 more expensive for this token mix. These are direct Moonshot costs, excluding tax and any earlier cache-write charges.

Opus 5.5 solved more tasks, but Pro beat GLM-5.3

Requesty's coding benchmark covers 25 models and 129 private Go backend tasks. Every model uses the same agent and tools, with an 80-turn budget. A task counts as solved only when it passes both hidden and existing tests.

These benchmark prices are the November 2026 list prices from the cheapest Requesty provider for each model. Cost per task includes retries.

Pro's cost per task was $0.08 lower than Opus's, but its lower solve rate put the cost per solve at $1.04, compared with $1.01 for Opus. GLM had the lowest listed token prices of the three and the highest measured cost per solve. For a coding team, the bill for completed work can tell a different story from the price list.

The difference was starker on the benchmark's 18 extreme tasks: Pro solved 39%, Opus solved 78% and GLM solved 6%. Use these Go backend results to build a shortlist, then test that shortlist on your own codebase.

Moonshot also reports Terminal-Bench 4.0 results of 65.7% for Pro and 66.4% for Opus 5.5. Moonshot evaluated Pro with Claude Code and selected comparison scores from model announcements or the official leaderboard. That is a separate test from Requesty's same-agent benchmark.

For the wider field, see our coding model benchmark comparison. Our Opus 5.5 guide covers its API access and pricing.

Faster output did not always mean faster task completion

Output tokens per second measures how quickly text arrives. Task time also includes the turns an agent takes and the waiting time between those turns.

GLM had the fastest measured output rate of the three in the Requesty benchmark, yet it took the longest per task on average and used more turns. We measured speed end to end from one region, including provider queueing and network time.

Token use explains GLM-5.3's higher cost per task

The models consumed different amounts of tokens over the course of a task. These figures come from the same Requesty coding benchmark.

GLM averaged 95,000 output tokens, more than seven times Pro's 13,000. That helps explain why its lower output-token price did not produce a lower cost per task in this test.

Cache behavior depends on the agent and provider. In Requesty's April 2026 coding-agent data, Claude Code had a 91.9% prompt-cache hit rate and OpenCode had 89.0%. Use your own cache mix when estimating a bill. For a broader view of list prices, see our LLM API price comparison.

How do you call both variants through Requesty?

Requesty's quickstart and chat completions reference document the OpenAI-compatible API. The examples below use standard Pro by default; set REQUESTY_MODEL to the managed Highspeed ID when you want that variant.

1. 1
   Set your Requesty API key

   Set REQUESTY_API_KEY in your environment. For Highspeed, also set the model variable:

   Shell

   Copy

   export REQUESTY_MODEL="kimi-k3.1-pro-highspeed"

   Leave REQUESTY_MODEL unset to use moonshot/kimi-k3.1-pro.

2. 2
   Send a chat completion

   Use the Requesty router base URL and your selected model:

   PythoncURL

   Python

   Copy

   import os
   from openai import OpenAI
    
   client = OpenAI(
       api_key=os.environ["REQUESTY_API_KEY"],
       base_url="https://router.requesty.ai/v1",
   )
    
   response = client.chat.completions.create(
       model=os.getenv("REQUESTY_MODEL", "moonshot/kimi-k3.1-pro"),
       messages=[
           {"role": "user", "content": "Write a Go function that reverses a string."}
       ],
   )
    
   print(response.choices[0].message.content)

The Highspeed model page lists Moonshot as its provider and input pricing from $4 per million tokens. For an agent setup, see how to use Claude Code with Kimi and GLM.

Which model should a coding team test first?

Run the same tasks with the same agent and budget for each candidate. Track end-to-end task time alongside output speed, then compare the cost of completed work.