LLM token cost calculator — language model API pricing

A token is the smallest unit of text a language model operates on: it can be a whole word, part of a word, a single character, or a punctuation mark. A token is not the same as a word: in English one token covers ~4 characters or ~0.75 words on average, while in Russian, because of the Cyrillic script, it covers only 2–3 characters, so a single word is often split into several tokens. Providers bill API usage by the number of input and output tokens, not by words or characters — which is why the LLMoney calculator does the exact count with each specific model's tokenizer.

Input tokens (prompt) are what you send to the model: the query, the system prompt, and the context. Output tokens (completion) are the text the model generates in response. They are billed separately, and output tokens are usually 2–5 times more expensive than input, since generation requires more compute. In the LLMoney table, the input and output cost of each model is shown in the separate "Input" and "Output" columns.

The context window is the maximum number of tokens a model can process in one request, including both the input text and the generated response. For example, GPT-4o has a window of up to 128K tokens, while GigaChat 2 Max supports up to 32K. The window is shared between input and output: the longer the prompt and attached documents, the fewer tokens are left for the answer. In the LLMoney table, each model's window size is listed in the "Context" column.

Reasoning models (the OpenAI o-series, DeepSeek reasoning editions, and the like) generate a chain of hidden reasoning before answering. You never see these "thinking" tokens in the response, but they are billed as output tokens — so the actual bill for a complex request can be several times higher than the answer length suggests. When estimating costs for such a model, build in a margin for output tokens: a low per-token price does not necessarily mean a cheap request.

One A4 page (~1,800 characters, ~300 words) is roughly 400–500 tokens for English text and 700–900 tokens for Russian. A 300-page book already amounts to hundreds of thousands of tokens, which matters when assessing context windows and cost. These are rough guidelines: the exact number depends on the model and the content (numbers, code, and punctuation tokenize differently). Paste your actual text into the calculator above to get an exact count for every model.

The tokenizers of most non-Russian LLMs are optimized for English, so Cyrillic is encoded less compactly: the same text in Russian takes 1.5–2 times more tokens than in English — and is therefore more expensive. The exception is the Russian models (GigaChat, YandexGPT), whose tokenizers are tuned for the Russian language. You can compare how many tokens your Russian text takes across different models right in the calculator.

Tools (function calling) are external functions the model can invoke while answering: web search, code execution, file search, calls to your API. This is paid for in tokens: the description of every tool is passed to the model, and each call and its returned result are all added to the input and output tokens on top of your text. The LLMoney calculator has a "Tools" panel that estimates this overhead and adds it to the request cost for every model.

Every tool consumes tokens in three places: the definition (passed once), the call (generated by the model), and the result (returned into the context). Web search is the heaviest: its results easily add thousands of tokens per call; file search and the code interpreter are more modest. Enable the tools you need in the "Tools" panel, set the number of calls — and you will see the "+input / +output" overhead in real time. Note that providers' separate fees for the tools themselves (for example, for web search) are not included in this token estimate.

Function calling means your own functions that the model invokes based on their descriptions (for example, "get the weather" or "create an order"). MCP (Model Context Protocol) is a standard by which a model connects to external tools and data sources. Both consume tokens for the description of each tool, plus for every call and its result. In the "Tools" panel you can set the number of your functions or MCP tools and the number of calls per request to estimate the resulting overhead.

Built-in tools are web search, code execution, file search and other functions the provider runs on its own side: you do not program them, you just enable them with an API parameter. Most major providers ship such tools (OpenAI, Anthropic, Google, Yandex, Mistral and others), but the sets differ a lot, and resale routers usually cannot expose vendor tools at all. In the LLMoney table, tool availability is shown as icons in the "Tools" column, the sidebar has a filter for them, and every model page lists the full set. Note: providers bill tool calls separately from tokens.

Function calling means your own functions: the model only decides when to call them, while your code executes them. Built-in tools, by contrast, are hosted by the provider itself — web search, a code sandbox, retrieval over uploaded files all run on its servers without your infrastructure. Practically every modern model supports function calling, so LLMoney does not list it separately, whereas built-in tool sets genuinely differ between providers — which is why they are surfaced in the table and on model pages. Tools consume tokens in both cases, and for built-in ones the provider may additionally charge per call.

An AI agent does not solve a task in one pass: it calls tools, gets the results, and queries the model again — several times over. Each such step adds tokens, so an agent can cost several times more than a single request. In the "Tools" panel, set the "calls" field to the expected number of tool invocations per task — the calculator will factor this into the "Request" column for every model, and you can compare which model runs the agent cheapest.

The cost of a request is made up of the input and output tokens multiplied by the model's rate per 1M tokens. The exact figures depend on the length of your prompt, the size of the response, and the share of cached input, and providers revise their rates from time to time. So instead of relying on numbers that go stale, paste a typical request into the calculator above — and you will see the current cost of one call to GPT-4o and to all the other models at once.

Among popular models, some of the most affordable are the light editions of the flagship lineups: GPT mini/nano models, Gemini Flash, DeepSeek, and GigaChat Lite. But the "cheapest" depends on the task: on simple queries a lightweight model saves money, while on complex ones it can degrade the result and end up costing more because of repeated calls. Sort the table above by the "Request" column to see the cheapest models for your specific text.

Prompt caching lets the provider reuse an already processed part of the context — for example, a long system prompt or a document repeated across requests. Cached input tokens are billed at a discount: with OpenAI and Anthropic they are noticeably cheaper than regular ones. The LLMoney calculator has an "Input cache" slider — set the share of cached input, and the table will recalculate the cost with the savings taken into account.

It is a trade-off between price and quality. On simple, routine tasks (classification, short answers, data extraction) a cheap model performs just as well and costs several times less. On complex ones (reasoning, code, long context) a weak model makes mistakes more often, and retries or manual fixes eat up all the savings. A good approach is to compare the cost of the same request for several models in the LLMoney table and test quality on the cheapest suitable one.

For Russian text, the standout price-to-quality options are the Russian models — GigaChat and YandexGPT: their tokenizers are tuned for Cyrillic, so they use fewer tokens on the same text, they are billed in rubles, and the data stays on servers in Russia (important for compliance with the Russian personal data law 152-FZ). Among non-Russian models, GPT-4o, Claude, and Gemini handle Russian well, but their less compact Cyrillic tokenization makes requests more expensive. Compare the cost of your specific Russian text for all models in the calculator above.

LLMoney tracks changes across all providers and updates its data within a few days of the official announcement. If you need the trend over time, the full price history of every model is available through the open API — the /models/{id}/price-history endpoint (see the "API for developers" section).

The official DeepSeek API does not accept Russian bank cards, but the model is available from providers in Russia: in the Yandex AI Studio and Cloud.ru Evolution clouds (inference in Russian data centers, billed in rubles) and through API routers such as AITunnel and VseGPT — the catalog marks these with a "router" badge, because they resell access at a markup rather than being the developer's official API. An up-to-date comparison of all offers, with prices per 1M tokens in rubles and dollars, is on the llmoney.ru/compare/deepseek page; prices are updated daily.

Paste a typical request into the calculator field and click "Calculate" (or press ⌘/Ctrl+Enter) — LLMoney will count the tokens and show the cost of one request for all models at once. The "Input", "Output", and "Request" columns show the breakdown and the total, and you can sort the table by price to pick the most cost-effective model. To estimate recurring costs, multiply the cost of one request by the expected number of calls (for example, requests per day × number of days).

Take a user message typical for your bot together with the system prompt, paste it into the calculator, and check the cost in the "Request" column for your chosen model. Multiply it by the number of requests per day and the number of days in a month to get a budget estimate. If the system prompt repeats in every request, raise the "Input cache" slider: caching noticeably reduces the cost of the repeated part.

Paste the document (or a representative excerpt) into the calculator — you will see how many tokens it takes for each model. Check that number against the "Context" column: the document must fit into the model's context window in full, otherwise you will have to split it into parts. Then compare the "Request" cost across models — at large volumes, the differences in per-1M-token rates become especially noticeable.

The length of a model's future response cannot be predicted in advance, so by default the calculator assumes the output token count is roughly equal to the size of your input text — that is the value in the "Output" column. If you know your responses will be noticeably longer or shorter than the input, adjust the total yourself, using the price per 1M output tokens in the "Output/1M" column as a guide.

BYOK (Bring Your Own Key) means using your own provider API keys inside LLMoney. After signing in with Yandex ID, you save your keys (OpenAI, Anthropic, GigaChat, YandexGPT, and others) and get: (1) exact token counts through the provider's server-side tokenizers instead of an approximate estimate, and (2) the ability to call models right from the interface. All keys are stored encrypted.

Yes. Sign in with Yandex ID, add the provider's API key in the settings, and select a model in the table — the expanded card will show a field for sending a request, and the model's response will appear next to it (OpenAI, Anthropic, GigaChat, and YandexGPT are supported). And with the ₽/$ switcher above the table you can change the currency at any moment — all prices are recalculated at the current exchange rate of the Central Bank of Russia.

Yes, LLMoney provides a free REST API for model and pricing data. The base URL is api.llmoney.ru/api/v1. Available endpoints: GET /models (list of models with prices), GET /models/{id} (model details), GET /models/{id}/price-history (price history), GET /recommend (model selection by parameters), POST /calculate (token and cost calculation). The full specification with request examples is on the llmoney.ru/api page, and the interactive Swagger documentation is at api.llmoney.ru/api/docs.

Use GET /api/v1/recommend with the parameters max_input_price and max_output_price (maximum price per 1M tokens), min_context_window, currency (usd/rub), provider, sort_by (input_price, output_price, or context_window), and limit. For example, /api/v1/recommend?max_input_price=5&currency=usd&sort_by=input_price&limit=5 returns the 5 cheapest models with an input price of up to $5 per 1M tokens. This is handy for AI agents (built on LangChain, AutoGPT, and the like) that pick a model for a task automatically.

llms.txt is an emerging standard for describing a service to AI agents. The file at api.llmoney.ru/llms.txt lists LLMoney's endpoints with request and response examples, so that an agent can discover the service automatically and understand how to fetch pricing data without studying the documentation by hand.