In Botmaker, all artificial intelligence features run on a generative model (also called an LLM). Every time your bot reads a message and replies, the model processes text, and that processing is measured and billed in tokens. That’s why your bot’s cost doesn’t depend on how many conversations you have, but on how much text the model reads and writes in each one, and on the model you choose.

You can:

• Understand which part of each conversation generates cost and why.
• Interpret the Input, Cached input, and Output prices shown in the Generative model window.
• Choose the best model for your use case based on quality and cost.
• Review your generative usage broken down by project, model, and function.
• Apply best practices so your bot uses fewer tokens.

Key concepts

Generative model (LLM): the “brain” your bot’s AI uses to understand what the customer writes and to draft a reply. Some models are simpler and more affordable; others are more powerful and more expensive. The model you choose affects the performance of your project’s AI agents, vector databases, and indexed text searches.

Token: the unit the model splits text into in order to process it. A token can be a short word, part of a word, or a punctuation mark. As a reference, 100 words in English are roughly 130 tokens. The model doesn’t count messages or characters: it counts tokens, which is why prices are expressed in tokens.

Price per million tokens: the way prices are displayed. For example, “US$ 0.40 per 1 million tokens” means that processing 1,000,000 tokens costs 40 cents. A single message uses a few thousand tokens, so the cost per message is a fraction of a cent; what matters is the total volume.

Input: all the text the model reads before replying. It’s not just the customer’s message: it also includes the agent’s instructions, tone, and restrictions, the conversation history, the information retrieved from your knowledge bases, and the results of tools and integrations. In most bots, the input is the part with the most tokens, because the model rereads all of that context with every message.

Cached input: the part of the input that repeats exactly from one message to the next, such as your agent’s fixed instructions. The model provider stores that text temporarily and, when it reuses it, charges much less than regular input (usually between 75% and 90% less). Think of it as part of the work being “already done.”

Output: the text the model writes: the reply to the customer and, depending on the model, its internal reasoning or tool calls. It’s the most expensive token.

Generative usage: the sum of all the tokens your project used in a given period, priced according to each model’s rates.

Why does each type of token have a different price?

If you look at any card in the Generative model window, you’ll see that output always costs more than input, and cached input is always the cheapest. There’s a technical reason behind this:

1. Reading is cheaper than writing. The model can read all the input text at once. To write the reply, however, it has to generate one token at a time, choosing each word based on the previous ones. That requires much more processing, which is why output usually costs about 4 times more than input.
2. Reusing is cheaper than reading. When the beginning of the input is exactly the same as in a previous message, the provider doesn’t need to process it again: it reuses the work it already did. That’s why cached input costs a fraction of regular input.

Why do prices differ between models and change over time?

Between models: more powerful models (those that reason better, follow long processes, or handle a lot of context) need more computing capacity for each token, so they cost more. Lighter models are more affordable and faster, and they handle most customer service tasks very well.

Over time: providers release new models frequently, and each generation usually delivers better performance at the same or a lower cost. When that happens, Botmaker updates the catalog: it adds new models and replaces older ones. That’s why some cards show a label indicating which model they replace.

Note: model names and prices change frequently. Always check the current values in the Generative model window. What doesn’t change is the logic: input, cached input, and output, each with its own price.

Example: how much does a message cost?

Imagine an agent that, with every message, reads 3,000 input tokens (2,000 of which are fixed instructions that stay cached) and replies with 200 tokens. With a model that costs US$ 0.40 for input, US$ 0.10 for cached input, and US$ 1.60 for output per million tokens:

• Input: 1,000 tokens × US$ 0.40 per million = US$ 0.0004
• Cached input: 2,000 tokens × US$ 0.10 per million = US$ 0.0002
• Output: 200 tokens × US$ 1.60 per million = US$ 0.00032
• Total per message: US$ 0.00092, which is about US$ 9.20 per 10,000 messages.

If that same agent didn’t benefit from caching, all 3,000 tokens would be billed as regular input and the cost would rise to about US$ 15.20 per 10,000 messages. In this example, caching saves about 40%.

And if you used an advanced model that costs, say, 20 times more per token, that same volume could cost over US$ 150. That’s why it pays to choose the model based on what your use case actually needs.

Note: the values in this example are for illustration only. Actual usage depends on the length of your instructions, the conversations, the resources each agent uses, and the model you choose.

How to choose your generative model

Step 1: Open the Generative model window

Open the Generative model window. You’ll see one card for each available model. You can scroll sideways to see them all.

Each card shows:

• The model’s name and provider.
• What it excels at (for example, advanced reasoning, high-volume customer service, or document analysis).
• Which use cases it’s recommended for, in the blue text in the middle.
• Cost per 1 million tokens for Input, Cached input, and Output.

By default, the Recommended model is selected. It offers the best balance between quality and cost for most bots.

Step 2: Compare and choose based on your use case

To choose, ask yourself two questions:

• How complex are your bot’s tasks? If it answers frequently asked questions, collects data, or routes conversations, an affordable model usually delivers the same result as an advanced one. If it has to reason through long processes, analyze documents, or make decisions based on many rules, a more powerful model may be worth it.
• How many conversations does it handle? At high volume, the price difference per token adds up. A slightly more expensive model can make a big difference by the end of the month.

We recommend always starting with the Recommended model and moving to a more powerful one only if the replies don’t reach the quality you need. A more expensive model doesn’t always answer better on simple tasks, but it always costs more.

How to review your usage

Step 1: Go to Products and usage

Go to Products and usage and open the generative usage view. You can also get there from the here link at the bottom of the Generative model window.

Step 2: Review the breakdown

Check the usage tables. You’ll see the breakdown by project, by model, and by function. Use each view to answer a different question:

• By project: which project uses the most?
• By model: how much of the cost comes from each model? Useful for measuring the impact after switching models.
• By function: which part of your operation uses the most (agents, searches, knowledge bases)?

Important considerations

• Caching is automatic: you don’t need to turn it on. It applies on its own when the beginning of the input repeats exactly, and it lasts for a limited time.
• More conversations don’t always explain higher usage: cost can go up with the same number of conversations if they’re longer, if you added instructions or resources, or if you switched models.
• Prices may change: they depend on the model providers and the current catalog. The Generative model window is always the reference.
• The model affects more than replies: the model you choose also affects the performance of your project’s vector databases and indexed text searches.

Remember to visit our Help Center for further information.