Kimi API Pricing vs Claude: Cost per Request Math

Our side of the comparison, in numbers

A fair look at kimi api pricing vs claude needs two price lists and one token count. This page can only supply one of the lists, and it is ours: $0.15 per 1M input tokens and $0.50 per 1M output tokens. For Anthropic's current rates, open their pricing page, because vendor prices change and a number copied into an article goes stale. Once you have both lists, the formula is the same for every provider.

cost = input tokens x input price / 1,000,000 + output tokens x output price / 1,000,000

Here is how that formula plays out for typical jobs on this service. Every figure is computed from the two prices above.

The full price sheet, including top-up bonuses, is on the pricing page.

How the bill is built

You pay for two kinds of tokens. Input tokens are everything you send: the system prompt, the chat history, documents, tool definitions and the new message. Output tokens are what the model writes back. Output costs $0.50 per 1M against $0.15 per 1M for input, so an output token is about 3.3 times the price of an input token (0.50 / 0.15 = 3.33).

That ratio shapes how you save money. A long prompt with a short answer is cheap: the 80,000-token document summary above costs $0.012 for input ($0.15 x 0.08) and $0.001 for 2,000 output tokens, so $0.013 in total. A short prompt that asks for a long essay is where output dominates. If you generate 100,000 output tokens, that is $0.05 on its own.

A few billing rules are worth knowing before you plan a budget:

• It is pay as you go from prepaid credit. There is no subscription and no minimum monthly spend.
• Failed or refused requests are not charged.
• Credit never expires, so a top-up you use slowly does not decay.
• Every response carries an X-Balance-USD header, so your own code can see the remaining credit after each call.

Measure your own cost per request

Estimates from a table help, but the response tells you exactly what happened. Every non-streamed reply includes a usage block, and streamed replies send it at the end. This script prices a call from those numbers, using the prices on this service.

Copyfrom openai import OpenAI

client = OpenAI(base_url="https://api.kimiapi.top/v1", api_key="YOUR_API_KEY")

IN_PRICE = 0.15   # USD per 1M input tokens
OUT_PRICE = 0.50  # USD per 1M output tokens

def cost(usage):
    return (usage.prompt_tokens * IN_PRICE
            + usage.completion_tokens * OUT_PRICE) / 1_000_000

reply = client.chat.completions.create(
    model="uncensored",
    messages=[{"role": "user", "content": "Explain prepaid API billing in 3 sentences."}],
)
u = reply.usage
print(u.prompt_tokens, u.completion_tokens, round(cost(u), 6))

Run it on a handful of real prompts from your product, not toy examples. Average the prompt and completion counts, then multiply by your expected number of requests. That average is the number to carry over to any other provider's calculator.

Comparing with Claude without guessing

To put Claude next to this service, follow four steps. They take ten minutes and they stay correct when prices move.

1. Get the current rates. Open Anthropic's pricing page and note the input and output price per 1M tokens for the exact model you would use. Models inside one family can differ a lot.
2. Get your token counts. Use the script above on a sample of real requests. Note average input and output tokens per request.
3. Apply the formula to both lists. Replace the two constants in the script with the other provider's numbers and run the same counts through.
4. Check the extras. Look at whether the other provider bills separately for cached prompts, long contexts or tool use, and whether the price changes above a certain prompt size. Here, the price is flat for the whole 100,000-token window.

Token counts for the same text can differ between providers, because each uses its own tokenizer. Treat a cross-provider comparison as close, not exact, and rerun it on real traffic before you commit a budget.

When the cheaper option is not the better one

Price per token does not decide a project. This service gives you one open-weight model, run by an independent provider, that answers without content refusals for lawful adult use. That is the reason to pick it: fiction, role-play and companion apps for adults, and other work where a hosted model with strict filters keeps refusing. The hard limit is that sexual content involving minors is never allowed.

There are cases where another provider is the better fit, and you should choose it without regret:

• You need image input, image generation, audio, embeddings or fine-tuning. This API is text only.
• You need a specific vendor's model, a vendor contract, or a vendor's support terms.
• Your task has strict accuracy needs and you have tested that a more expensive model does it better. Run both on your own evaluation set; do not rely on a general reputation.
• You never see refusals on your content, so the main reason to switch is gone.

If you are unsure, run the same fifty prompts through both and look at the answers and the bill. The Kimi K2 setup and costs guide on this site walks through a first request if you want to test the model quickly.

Top-ups, bonuses and the free trial

You can top up any whole amount from $20 to $500. Larger top-ups add a bonus on top of what you pay: +5% from $50, +10% from $100 and +15% from $200. The credit you receive works out like this:

Pay by card (Visa, Mastercard, Apple Pay, Google Pay) or by crypto (USDT on TRC20, USDC on Base). At the chat-turn price from the first table, $20 of credit covers about 36,000 turns of 2,000 input and 500 output tokens (20 / 0.00055 = 36,363).

If you want to see real numbers before paying, new users can claim $0.50 of trial credit with one click on the API key page after sign-up. It needs no card, lasts 7 days and is limited to one per person. At 2,000 input and 500 output tokens per turn, that is about 909 turns, which is enough to run the measuring script on a large sample.

Costs that surprise people

The most common budget mistake is forgetting that a chat client resends the whole history on every turn. Input tokens grow with every message, even when each answer stays short. Take a 30-turn conversation where the prompt averages 6,000 tokens and each reply is 300 tokens. Input is 30 x 6,000 = 180,000 tokens, which costs $0.027. Output is 30 x 300 = 9,000 tokens, which costs $0.0045. The conversation costs $0.0315 in total, and most of it is input you already paid for in earlier turns.

Three habits keep that in check. Trim or summarise old messages once the history passes a size you choose. Keep the system prompt short and put long reference text only in the calls that need it. Set max_tokens when you know a reply should stay brief, since it is optional here and the completion may otherwise use the rest of the window. The docs list every request field.

More guides

• Kimi API Base URL and How to Set It Up
• Kimi API Rate Limit: Our Limits and Context Window
• Uncensored LLM API Guide: Kimi K2 Setup & Costs