Token calculator

A token is a unit produced by an encoder: a word, part of a word, punctuation or part of a character. There is no universal character-to-token conversion; the result depends on the text and encoder. Select a model and check the method shown. The ≈ sign means an approximation. Providers charge input and output separately, and a complete API request may include additional protocol tokens.

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.

Context limits the size of a request and response. Verified limits are 128000 total tokens and 16384 output tokens for GPT-4o, and 1047576 total / 32768 output for GPT-4.1. The calculator includes entered text, expected output and specified tool overhead, but not the full request format. Other models currently have an unknown context status; the older number in the Context column alone does not guarantee a request will fit.

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.

Page count cannot reliably predict tokens: language, code, tables and the encoder all matter. Paste the text, select a model and check the count together with its method. OpenAI models use their configured encoder; other families show an estimate. File uploads are not supported yet.

The ratio depends on the actual text and encoder, so there is no universal multiplier for Russian. For example, “Привет, мир! Сколько токенов в этом предложении?” has 15 tokens with o200k_base and 21 with cl100k_base. For models with different native tokenizers, cl100k_base is only an estimate and cannot establish an advantage on Russian text.

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.

Choose based on the task, response quality, tariffs and provider terms. This calculator compares estimated costs for your inputs; it does not measure Russian-language quality or verify data residency. Local tokenization for non-OpenAI models is approximate. Check the selected API terms and actual usage.

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 text and select a model: the count appears after a short pause without sending text to a server. Enter expected output separately; the default is 0, so the initial estimate includes input only. The table compares current catalog prices and the context check separates fitting models from unknown limits. For a monthly estimate, open Advanced and set requests per day.

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.

Future response length is unknown. Expected output defaults to 0, so only input is counted initially. Choose 500, 2000 or a custom integer token count. An input multiplier remains available in Advanced. This is your assumption; hidden reasoning tokens and actual usage may change the bill.

BYOK lets you call a supported model using your own key. Keys are stored encrypted; the explicit call button sends text through LLMoney to the provider and creates a paid call. Normal counting and token breakdown remain local even with saved keys. The public server-side /calculate endpoint can use native GigaChat and Yandex tokenization where supported; a Claude key does not turn the cl100k estimate into an exact count.

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.

Yes. Install Node.js 22+ and connect the published npm package llmoney-mcp@0.2.0. For Claude Code: claude mcp add llmoney -- npx -y llmoney-mcp@0.2.0. Other MCP client settings are on /en/api. Access to the private source repository, provider keys and LLMoney registration are not required. When estimating costs from text, MCP sends it to the LLMoney API; token counts for many models are approximate. The REST API is also available directly.

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.