> For the complete documentation index, see [llms.txt](https://docs.zerve.ai/zerve-docs/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.zerve.ai/zerve-docs/administration/how-credits-are-used.md).

# How credits are used

What uses credits in Zerve, how much models cost, and how to keep spending in check.

**Credits** are Zerve's unit of usage. Everything that costs Zerve money to run, from the models behind the agents to the compute that runs your code, is measured in credits, so you can track and budget usage the same way whatever you're doing.

## Credits and tokens

Credits and tokens measure different things.

* **Tokens** are the units models read and write. A token is roughly three-quarters of a word. Model providers charge separately for the tokens you send (input) and the tokens the model writes (output), and output usually costs several times more.
* **Credits** are Zerve's own unit, combining model usage and compute into one number.

There's **no fixed number of tokens per credit**. The same number of credits buys many more tokens on a small, fast model than on a large one, and compute uses credits without involving tokens at all.

## What uses credits

Credits are only used for what Zerve runs for you:

| What            | How it's charged                                                                                |
| --------------- | ----------------------------------------------------------------------------------------------- |
| **Model usage** | When the agents call a model, you're charged the model provider's price plus 20%                |
| **Compute**     | When your code runs on Zerve's compute, you're charged by the second, based on the compute type |

Calls your code makes to external services, such as a market data API, aren't charged as credits themselves. They only use credits through the compute time of the block that runs them.

If your organization uses [its own API keys](/zerve-docs/administration/bring-your-own-api-keys.md), you pay the model provider directly, and Zerve charges credits for orchestration at a reduced rate.

## What a credit is worth

Credits work out at about **$0.10** each: add-on credits are sold in packs of 250 for $25 on the Pro plan and 500 for $50 on the Team plan. See [Plans, credits and billing](/zerve-docs/administration/plans-credits-and-billing.md).

## Working out the cost of model usage

```
credits = (provider price for the tokens used × 1.2) ÷ $0.10
```

**Example.** Claude Sonnet 4.6 costs $3 per million input tokens and $15 per million output tokens. A request that sends 10,000 tokens and gets 2,000 back costs:

| Step                                   | Amount           |
| -------------------------------------- | ---------------- |
| Input: 10,000 tokens × $3 per million  | $0.03            |
| Output: 2,000 tokens × $15 per million | $0.03            |
| Provider price                         | $0.06            |
| Plus 20%                               | $0.072           |
| **In credits, at $0.10 each**          | **0.72 credits** |

A single agent task usually involves many requests like this, as the agent reads, plans, writes code and checks results.

## Model prices

These are the provider prices for some commonly used models, with the equivalent in credits (price × 1.2 ÷ $0.10). Prices are per million tokens.

{% hint style="info" %}
Prices last checked on 2 October 2026. Providers change prices often, so check their pricing pages for current rates: [Anthropic](https://platform.claude.com/docs/en/about-claude/pricing), [OpenAI](https://developers.openai.com/api/docs/pricing), [Google Gemini](https://ai.google.dev/gemini-api/docs/pricing), [Amazon Bedrock](https://aws.amazon.com/bedrock/pricing/) and [OpenRouter](https://openrouter.ai/models).
{% endhint %}

| Model             | Input price | Output price | Input credits | Output credits |
| ----------------- | ----------- | ------------ | ------------- | -------------- |
| Claude Haiku 4.5  | $1          | $5           | 12            | 60             |
| Claude Sonnet 4.6 | $3          | $15          | 36            | 180            |
| Claude Sonnet 5.5 | $2          | $10          | 24            | 120            |
| Claude Opus 5.5   | $4          | $20          | 48            | 240            |
| gpt-5.5           | $5          | $30          | 60            | 360            |
| gpt-5.6-terra     | $2          | $12          | 24            | 144            |
| Gemini 3.8 Flash  | $0.75       | $3.75        | 9             | 45             |

Some prices are temporary. Gemini 3.8 Flash's price, for example, is an introductory one until 31 December 2026.

## What affects how many credits a task uses

| Factor                       | Effect                                                                                                                                                                               |
| ---------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| **The model**                | Larger models cost many times more per token than smaller ones                                                                                                                       |
| **Output**                   | Output tokens cost several times more than input tokens                                                                                                                              |
| **Reasoning effort**         | Higher [reasoning effort](/zerve-docs/agents-in-the-workspace/models-and-effort.md#reasoning-effort) means the model writes more tokens while it thinks, which are charged as output |
| **How much context is sent** | Long conversations, large files and big notebooks mean more input tokens with every request                                                                                          |
| **Tokenizers**               | Models count tokens differently. For example, newer Claude models count about 30% more tokens for the same text.                                                                     |
| **The mode**                 | Evolve Mode and superagents run several agents at once, so they use more than Ask or Build                                                                                           |
| **Compute**                  | Larger compute, GPUs and longer runs use more                                                                                                                                        |

## What Zerve does to keep costs down

* **Caching.** Zerve reuses the parts of a request that don't change between calls, which providers charge much less for.
* **Limited history.** Superagents only send the most recent part of a long conversation with each request, so long-running chats don't get more expensive over time.
* **Time limits.** Each agent run stops after 60 minutes.

## Controlling spending

| Control                                                                          | What it limits                                                             | Where to set it                                                                                                                                                         |
| -------------------------------------------------------------------------------- | -------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| [**Credit cap**](/zerve-docs/agents-in-the-workspace/evolve-mode/credit-caps.md) | A single Evolve Mode run. Default 50 credits.                              | Evolve Mode settings in the composer                                                                                                                                    |
| [**Daily budget**](/zerve-docs/superagents/budgets-and-credits.md)               | A superagent's whole team, per day. Default and maximum 25,000 credits.    | The superagent's settings                                                                                                                                               |
| **Model choice**                                                                 | How much each request costs                                                | [Models and effort](/zerve-docs/agents-in-the-workspace/models-and-effort.md), and the [models your organization enables](/zerve-docs/administration/model-settings.md) |
| **Auto-recharge**                                                                | Whether your organization buys more credits automatically when it runs low | [Plans, credits and billing](/zerve-docs/administration/plans-credits-and-billing.md)                                                                                   |

## Seeing what you've used

Organization admins can see usage in **Settings**, under **Credit Usage** and **Compute Usage**. For a superagent, its page shows credits used today and in the last 24 hours.

## When credits run out

When your organization's plan credits and add-on credits are both used up, work that uses credits stops until more are available. See [Plans, credits and billing](/zerve-docs/administration/plans-credits-and-billing.md).


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation by asking a question.

Perform an HTTP GET request on the following URL with the `ask` and `goal` query parameters:

```
GET https://docs.zerve.ai/zerve-docs/administration/how-credits-are-used.md?ask=<question>&goal=<user_goal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is what the user is ultimately trying to achieve, the reason they need the answer. Sharing it helps GitBook give you a better, more relevant answer. A goal is most helpful when it describes the outcome the user wants rather than restating the question. For example, with `ask=how do I create an API token`, a goal like `automate deployments from our CI pipeline` lets GitBook tailor the answer to that use case.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.