How tokens are counted

Every AI request is measured in tokens, and you pay per token. This page explains which tokens a request uses, where the counts come from, how total tokens add up, and how the counts become a charge. The worked examples show each step, so you can check the arithmetic against your own requests.

What a token is

A token is a small piece of text: a short word, part of a longer word, a number or a punctuation mark. Models read your input and write their output as tokens. Each model splits text into tokens in its own way, so the same text can be a different number of tokens on different models. As a rough guide, one token is about four characters of English text. Other languages, code and numbers often take more tokens for the same length. Images you send also count as input tokens, and the model decides how many.

The tokens in a request

Kind	What it counts	Charged at
Input tokens	Everything you send: the system prompt, every message in the conversation, and your tool definitions.	The input price
Cached input	The part of the input the model read from its prompt cache. It’s part of the input tokens, not extra.	The cache read price
Cache writes	The part of the input the model stored in its prompt cache for later requests. It’s also part of the input tokens.	The cache write price for the duration: standard or 1 hour
Output tokens	Everything the model writes: the reply, tool calls and any reasoning.	The output price
Reasoning tokens	The thinking a reasoning model does before it answers. They’re part of the output tokens, not extra.	The output price

If a model has no cache read price, or no price for a cache write duration, those tokens are charged at the input price. Each model’s prices are on Models and pricing.

A request doesn’t remember earlier requests. To continue a conversation, your app sends the whole conversation again, so every earlier message and reply counts as input tokens again. Input tokens grow as a conversation gets longer.

Where the counts come from

The model counts the tokens of each request and reports the counts with its reply. SinarCloud records those counts, and they’re the counts you’re charged for. You see them in the API response, in the Playground and on the Usage page. SinarCloud records the counts of a streamed request too, even when your request doesn’t ask for them in the stream.

When SinarCloud counts the tokens itself

Sometimes a reply arrives without the model’s counts, for example when you stop a stream before it ends. SinarCloud then counts the tokens itself, from your request and the output that was sent to you, and charges that count. It’s an estimate, so it can differ from the model’s own count. An estimate doesn’t know which input came from the cache, so all of its input tokens are charged at the input price. If the model stops a stream before it finishes:

When none of the answer has reached you yet, SinarCloud sends the request to the model once more, and the stream continues with the new reply. You’re charged once, for the request that finished.
When part of the answer has already reached you, or the second try is cut off too, the stream ends with the error “The model’s answer was cut off before it finished. Send the request again.” That request isn’t charged.

Total tokens

Total tokens are the input tokens plus the output tokens:

total tokens  = input tokens + output tokens

input tokens  = uncached input + cached input + cache writes
output tokens = reply and tool calls + reasoning tokens

Cached input, cache writes and reasoning tokens are already inside the input and output tokens. Don’t add them again. For example, a request sends 2,000 input tokens, and the model reads 1,500 of them from the cache. The model then writes 400 output tokens, 150 of them reasoning. The total is 2,000 + 400 = 2,400 tokens, not 2,000 + 1,500 + 400 + 150. You see the total in these places:

API response: usage.total_tokens on the OpenAI format endpoints. The Anthropic Messages format has no total, so add its counts as shown in Anthropic Messages format.
Playground: under each reply, next to the input and output tokens.
Usage page: the Tokens column of the Log shows each request’s total. The Tokens processed card adds up the totals of every request in the date range.
Token credits: a request uses one token of credit for each input token and each output token, so as many as its total. See Token credits.

Read the counts in an API response

OpenAI format

A chat completion returns its counts in usage. For the request in the example above, it looks like this:

{
  "usage": {
    "prompt_tokens": 2000,
    "completion_tokens": 400,
    "total_tokens": 2400,
    "prompt_tokens_details": {
      "cached_tokens": 1500
    },
    "completion_tokens_details": {
      "reasoning_tokens": 150
    }
  }
}

Field	What it counts
`prompt_tokens`	Input tokens, including cached input and cache writes
`prompt_tokens_details.cached_tokens`	Cached input
`completion_tokens`	Output tokens, including reasoning tokens
`completion_tokens_details.reasoning_tokens`	Reasoning tokens
`total_tokens`	`prompt_tokens` plus `completion_tokens`

Some models add other fields to usage, or leave out a details field they don’t report. Treat a missing count as zero. To print the counts with the OpenAI SDK for Python:

import os
from openai import OpenAI

client = OpenAI(
    base_url="https://ai.sinarcloud.com/v1",
    api_key=os.environ["SINARCLOUD_API_KEY"],
)

completion = client.chat.completions.create(
    model="deepseek/deepseek-v4-1-flash",
    messages=[{"role": "user", "content": "Hello"}],
)

usage = completion.usage
details = usage.prompt_tokens_details
cached = details.cached_tokens if details and details.cached_tokens else 0
print(f"input {usage.prompt_tokens} ({cached} cached), "
      f"output {usage.completion_tokens}, total {usage.total_tokens}")

To get usage in a streamed chat completion, add "stream_options": {"include_usage": true} to the request. The counts then arrive in the last chunk of the stream. /v1/completions uses the same fields as chat completions. The other OpenAI format endpoints name the counts differently:

/v1/responses: input_tokens, with the cached input in input_tokens_details.cached_tokens. Then output_tokens, with the reasoning tokens in output_tokens_details.reasoning_tokens, and total_tokens.
/v1/embeddings: prompt_tokens and total_tokens. Embeddings have no output tokens.

Anthropic Messages format

/v1/messages reports the input in parts. The same request looks like this:

{
  "usage": {
    "input_tokens": 500,
    "cache_read_input_tokens": 1500,
    "cache_creation_input_tokens": 0,
    "output_tokens": 400
  }
}

Here input_tokens counts only the input that wasn’t read from or written to the cache. To get the input tokens that SinarCloud charges and shows, add the three input fields. A field the model doesn’t report can be missing; count it as zero.

input tokens = input_tokens + cache_read_input_tokens + cache_creation_input_tokens
             = 500 + 1,500 + 0
             = 2,000

total tokens = input tokens + output_tokens
             = 2,000 + 400
             = 2,400

output_tokens includes any thinking the model does. The Messages format has no total field.

From tokens to a charge

The full price of a request is:

full price = ( uncached input × input price
             + cached input   × cache read price
             + cache writes   × cache write price
             + output tokens  × output price ) ÷ 1,000,000

uncached input = input tokens − cached input − cache writes

Prices are per 1M tokens. Charges aren’t rounded to whole rupiah, but a request that costs anything has a full price of at least Rp 0.6. Token credits pay first, a promotion discounts what’s left, and your balance pays the rest. A promotion that makes the model free applies before token credits. See How requests are charged. Examples 1 to 5 use round prices to keep the arithmetic simple. Example 6 uses a real model’s prices. Each model’s current prices are on the Models page.

Price	Example price per 1M tokens
Input	Rp 10,000
Cache read	Rp 1,000
Cache write (standard)	Rp 12,500
Output	Rp 40,000

Example 1: a short request

You send 800 input tokens and get 200 output tokens back, so 1,000 tokens in total. Nothing comes from the cache.

Part	Tokens	Price per 1M	Cost
Input	800	Rp 10,000	Rp 8
Output	200	Rp 40,000	Rp 8
Full price	1,000		Rp 16

Example 2: a request that reads the cache

This is the request from Total tokens: 2,000 input tokens with 1,500 of them cached, and 400 output tokens with 150 of them reasoning.

Part	Tokens	Price per 1M	Cost
Uncached input	500	Rp 10,000	Rp 5
Cached input	1,500	Rp 1,000	Rp 1.5
Output, reasoning included	400	Rp 40,000	Rp 16
Full price	2,400		Rp 22.5

Without the cache, the same 2,000 input tokens would cost Rp 20 instead of Rp 6.5, and the full price would be Rp 36. The cache changes the price, not the count: the total is 2,400 tokens either way. The request’s cache hit is 1,500 ÷ 2,000 = 75%.

Example 3: a request that writes the cache

On a model with a cache write price, you can mark the start of your prompt for caching with cache_control. See Prompt caching. Say the first request writes those 1,500 tokens to the cache, with the standard duration:

Part	Tokens	Price per 1M	Cost
Uncached input	500	Rp 10,000	Rp 5
Cache writes	1,500	Rp 12,500	Rp 18.75
Output	400	Rp 40,000	Rp 16
Full price	2,400		Rp 39.75

Writing to the cache costs more than plain input. It pays off when later requests read those tokens back while they’re cached: each one then costs Rp 22.5, as in Example 2, instead of Rp 36.

Example 4: a very small request

You send 20 input tokens and get 5 output tokens back.

Part	Tokens	Price per 1M	Cost
Input	20	Rp 10,000	Rp 0.2
Output	5	Rp 40,000	Rp 0.2
Tokens	25		Rp 0.4
Full price			Rp 0.6

The tokens cost Rp 0.4, which is below the minimum, so the full price is Rp 0.6. Requests on a free model, and requests that use no tokens, stay free.

Example 5: token credits pay part of a request

You have 1,000 tokens of credit left for the model, and you send the request from Example 2: 2,400 tokens with a full price of Rp 22.5. Credits cover 1,000 of its 2,400 tokens, so they pay the same share of the price:

token credits pay = Rp 22.5 × 1,000 ÷ 2,400 = Rp 9.375
balance pays      = Rp 22.5 − Rp 9.375      = Rp 13.125

Example 6: a coding session paid from token credits

Token credits count every token once, whether it came from the cache or not. Say you have 100,000,000 tokens of credit for DeepSeek V4.1 Flash, and you send these four requests:

Request	Uncached input	Cached input	Output
1. First message of a coding session	20,000	0	1,500
2. Next turn in the same session	5,032	19,968	800
3. A turn deep in a long agent session	9,300	132,700	700
4. A short chat question	300	0	400

Each request uses its total tokens from your credits:

Request	Tokens used	Tokens left	Full price
1. First message	21,500	99,978,500	Rp 16.3
2. Next turn	25,800	99,952,700	Rp 4.98432
3. Long session turn	142,700	99,810,000	Rp 12.888
4. Short question	700	99,809,300	Rp 0.6

Tokens used is the uncached input, the cached input and the output added up: the request’s total tokens. Your token credits cover all of them, so Tokens left goes down by the total each time.
Full price is what the same request costs from your balance when you have no token credits for the model. It uses DeepSeek V4.1 Flash’s prices on 31 October 2026: input Rp 800, cache read Rp 40 and output Rp 200 per 1M tokens. Prices can change, so check the Models page for the current ones.
Request 3 uses the most credit, 142,700 tokens, but its full price is only Rp 12.888. Most of its input came from the cache, which is cheap in rupiah, but each cached token still uses one token of credit.
The tokens of request 4 cost Rp 0.32, which is below the minimum, so its full price is Rp 0.6.

This is the arithmetic for request 3:

full price = ( 9,300 × 800 + 132,700 × 40 + 700 × 200 ) ÷ 1,000,000
           = ( 7,440,000 + 5,308,000 + 140,000 ) ÷ 1,000,000
           = Rp 12.888

Together, the four requests use 190,700 tokens of credit, and 99,809,300 are left. Paid from your balance instead, they would cost Rp 34.77232. To see the same session on a subscription plan, including a Cache-Free plan that doesn’t count cached input, see Example: a week of usage.

See the counts in the console

On the Usage page

In the console sidebar, under AI, click Usage.
On the Log tab, click Show details on a request.

The Log tab's Recent requests table with the newest request expanded. Its Tokens column shows 4,185, and its details read 3,643 in · 542 out, Cache hit: 50% · 1,821 cached tokens, and Cache writes: 0 standard · 0 1h, with a Settled status and a Charge breakdown where token credits covered 4,185 tokens. — A request's tokens in the Log

Read the details of the expanded request in the screenshot like this:

3,643 in · 542 out under Tokens: 3,643 input tokens and 542 output tokens. The Tokens column shows their total, 4,185.
Cache hit: 50% · 1,821 cached tokens: 1,821 of the 3,643 input tokens came from the cache. 1,821 ÷ 3,643 is 50%, rounded.
Cache writes: 0 standard · 0 1h: the request wrote nothing to the cache.
4,185 tokens covered next to Token credits: token credits paid for every input and output token of the request.

At the top of the page, Tokens processed adds up the total tokens of every request in the date range, with the input and output tokens below it. On the Tokens tab, the daily chart stacks Other input, Cached input and Output tokens. Other input and cached input together are your input tokens. See Usage and spending.

In the Playground

Under each reply, the Playground shows the input, output and total tokens, and the cache hit. When billing is final, they update to the counts you were charged for. See Playground.

Count tokens before you send

POST /v1/messages/count_tokens counts the input tokens of an Anthropic Messages request without running it. It’s free, and it doesn’t need max_tokens.

curl "https://ai.sinarcloud.com/v1/messages/count_tokens" \
  -H "x-api-key: $SINARCLOUD_API_KEY" \
  -H "anthropic-version: 2023-06-01" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "deepseek/deepseek-v4-1-flash",
    "messages": [{"role": "user", "content": "Hello"}]
  }'

The response has one field, input_tokens. SinarCloud counts them itself instead of asking the model, so the count is an estimate. The input tokens the model reports when you send the request are the ones you’re charged for, and they can differ. The OpenAI format has no count endpoint. To see how many tokens a prompt uses, send it once with a low output limit, or try it in the Playground, and read the counts.

Use fewer tokens

Start a new conversation when you change topics. Every request sends the whole conversation again.
Keep the parts that don’t change, such as the system prompt and tool definitions, at the start of your prompt. Models that cache can then read them from the cache, at the cache read price.
Set an output limit with max_completion_tokens or max_tokens, so a reply can’t run longer than you need. Output tokens usually cost more than input tokens.
Reasoning tokens are output tokens. A model that reasons can write many more tokens than the answer itself.
Give each app or tool its own API key, then filter the Usage page by that key to see how many tokens it uses.

Models and pricing

See each model’s input, output and cache prices.

Usage and spending

Track the tokens and charges of every request.

Get started

VPS

Billing

AI API

Account

Help

How tokens are counted

What a token is

The tokens in a request

Where the counts come from

When SinarCloud counts the tokens itself

Total tokens

Read the counts in an API response

OpenAI format

Anthropic Messages format

From tokens to a charge

Example 1: a short request

Example 2: a request that reads the cache

Example 3: a request that writes the cache

Example 4: a very small request

Example 5: token credits pay part of a request

Example 6: a coding session paid from token credits

See the counts in the console

On the Usage page

In the Playground

Count tokens before you send

Use fewer tokens

Models and pricing

Usage and spending

​What a token is

​The tokens in a request

​Where the counts come from

​When SinarCloud counts the tokens itself

​Total tokens

​Read the counts in an API response

​OpenAI format

​Anthropic Messages format

​From tokens to a charge

​Example 1: a short request

​Example 2: a request that reads the cache

​Example 3: a request that writes the cache

​Example 4: a very small request

​Example 5: token credits pay part of a request

​Example 6: a coding session paid from token credits

​See the counts in the console

​On the Usage page

​In the Playground

​Count tokens before you send

​Use fewer tokens

Models and pricing

Usage and spending

What a token is

The tokens in a request

Where the counts come from

When SinarCloud counts the tokens itself

Total tokens

Read the counts in an API response

OpenAI format

Anthropic Messages format

From tokens to a charge

Example 1: a short request

Example 2: a request that reads the cache

Example 3: a request that writes the cache

Example 4: a very small request

Example 5: token credits pay part of a request

Example 6: a coding session paid from token credits

See the counts in the console

On the Usage page

In the Playground

Count tokens before you send

Use fewer tokens