How do you calculate the cost of an AI API?

In short: API cost is token count times token price: input tokens are multiplied by the input price, output tokens by the output price, cached input by its own price, and the results are added up. Prices are quoted per 1 million tokens. For example, on the Wiozen API a request to wiozen-anthropic with 2,000 input tokens and 1,000 output tokens costs 2,000 × $0.05 / 1,000,000 + 1,000 × $0.20 / 1,000,000 = $0.0003.

What is a token, and why are input and output priced separately?

A model reads and writes text in small pieces called tokens. As a rough guide, 1 million tokens of English text is about 750,000 words. Other languages often take more tokens for the same length; Turkish, with its long suffixed words, is one of them. Rather than guessing, look at the token counts the API returns with every response.

Input is everything you send: the system message, earlier messages in the conversation, any file or code you attach. Output is what the model writes back. Providers charge more for output. For the chat models on the Wiozen API's Models page, output costs 4 to 5 times the input price: wiozen-anthropic is $0.05 in and $0.20 out, claude-sonnet-5-5 is $1.40 in and $7.00 out.

In a chat, every new message is sent together with the messages before it. That's why the later messages in a long conversation cost more than the first ones: the part that grows is the input.

The formula

cost = ( input tokens × input price
       + cached tokens × cache read price
       + output tokens × output price ) / 1,000,000

The Wiozen API has four separate prices: input, cached input read, cache write and output. A short chat question doesn't touch the cache, so the cost is just input plus output. You can see the cache prices on the Models page by hovering over the input price.

An example with real prices

The table below uses the prices listed on the Models page on October 27, 2026. The sample message is 2,000 input tokens and 1,000 output tokens: a short question and answer with no cache.

For the claude-sonnet-5-5 row the arithmetic is: 2,000 × 1.40 / 1,000,000 = $0.0028 for input, 1,000 × 7.00 / 1,000,000 = $0.007 for output, $0.0098 in total. $5 / $0.0098 ≈ 510.

For deepseek-v4.1-flash the table shows the peak-hours price, which applies on weekdays from 04:00 to 07:00 and from 09:00 to 13:00 Turkey time. At all other hours and on weekends half of that price applies, so the same message costs $0.00045.

How does caching lower the cost of long contexts?

Coding agents send the same files, the same instructions and the conversation history again at every step. When that repeated part is read from the cache, it is charged at a much lower rate. Going by the prices on the Models page, cached input costs a tenth of normal input or less.

Take a typical agent step: 15,000 new input tokens, 83,000 tokens read from the cache and 2,000 output tokens.

• claude-sonnet-5-5 (cache read $0.14): 15,000 × 1.40 + 83,000 × 0.14 + 2,000 × 7.00, divided by 1,000,000 = $0.021 + $0.01162 + $0.014 = $0.04662.
• The same step without the cache, with all 98,000 tokens as normal input: $0.1372 + $0.014 = $0.1512, more than three times as much.
• The same step on wiozen-anthropic (cache read $0.005): $0.00075 + $0.000415 + $0.0004 = $0.001565. $1 covers about 638 such steps.

Caching is used by the tool that sends the request; agents like Claude Code do it on their own. How many tokens came from the cache is shown for each request on the Usage page of the dashboard.

How does the balance go down per request?

• When a request starts, an estimated cost is held from your balance, and when the response ends it is corrected to the real cost. A much larger max_tokens than you need makes that temporary hold larger; keep this in mind when your balance is low.
• Failed requests are not charged. /v1/messages/count_tokens, which counts tokens, is free as well.
• When the balance runs out, new requests return 429. If a single request costs more than what's left, the difference is taken from your next top-up.
• You can give a key a spending cap. When the cap is reached only that key stops.

Measuring your own cost in code

Every response reports the tokens it used in the usage field. In the OpenAI format the fields are prompt_tokens and completion_tokens; in the Anthropic format they are input_tokens and output_tokens. Multiply them by the prices and you can log the cost of each request yourself:

from openai import OpenAI

client = OpenAI(base_url="https://api.wiozen.com/v1", api_key="sk-gw-...")
# dollars per 1M tokens: (input, output)
PRICES = {"wiozen-anthropic": (0.05, 0.20), "claude-sonnet-5-5": (1.40, 7.00)}

model = "wiozen-anthropic"
r = client.chat.completions.create(
    model=model,
    messages=[{"role": "user", "content": "Hello"}],
    max_tokens=16000,
)
p_in, p_out = PRICES[model]
cost = (r.usage.prompt_tokens * p_in + r.usage.completion_tokens * p_out) / 1_000_000
print(f"{r.usage.prompt_tokens} in, {r.usage.completion_tokens} out: ${cost:.6f}")

This example doesn't count cached tokens separately, so treat it as an estimate that works well for short requests. The exact figure is the breakdown on the Usage page of your dashboard.

Frequently asked questions

To see the numbers with your own requests, create an account. With the $0.15 trial balance you can send a few requests and see what each one cost, line by line, on the Usage page.

Create your account

More guides: How can you use an AI API from Turkey without a credit card? · How do you connect an OpenAI-compatible API to a tool you already use? · How do you get AI to write and publish articles in WordPress automatically? · How do you find blog topics from RSS feeds and Google Trends? · Does AI-written content show up on Google and in AI answers?