# Pricing

URL: https://docs.hanzo.ai/docs/pricing

> What a request costs — the Enso tiers, per-token billing for every other model, and the per-call rates for tools, images and audio.

**After this page you can work out what a request will cost before you send
it, and pick the tier that makes that number worth paying.**

You are billed for what you use — tokens for a chat model, calls for a tool,
images for an image model. There is no seat licence and no minimum: an
account that sends nothing is charged nothing.

Every rate below is per **million tokens** unless the table says otherwise,
in US dollars.

## The Enso tiers

Enso is Hanzo's own family. Each paid tier runs a chain of frontier
models under one id and one price, and a call bills that price whichever
model answered it.

| Model        | Input | Output |
| ------------ | ----- | ------ |
| `enso`       | $0.33 | $1.65  |
| `enso-auto`  | $0.33 | $1.65  |
| `enso-flash` | $0.33 | $1.65  |
| `hanzo/enso` | $0.33 | $1.65  |
| `enso-pro`   | $4.40 | $22.00 |
| `enso-ultra` | $5.50 | $27.50 |

`enso-free` answer with free models and
bill nothing. On a paid plan each of them but `enso-free` is lifted to
the tier the request's reasoning depth asks for, and bills that tier.

Cache read and write rates, the models behind each tier, and a worked
cost for an agent turn: [Enso](https://docs.hanzo.ai/docs/models/enso).

## Every other model

Alongside the Enso and Zen families the gateway carries models from outside
labs, on the same key and the same endpoint. Each is billed at its own
published rate.

Those rates move as providers change theirs, so they are not reprinted here.
The catalogue at [**Models**](https://docs.hanzo.ai/docs/models) fetches them in your browser as
you read, which means it is current without waiting for a docs deploy — read
the price there, next to the model id you are about to paste.

**82 of them cost nothing**, in or out, subject to
rate limits. They are not named by a common convention, so list them from
the API rather than guessing at the id:

```bash
curl -s https://api.hanzo.ai/v1/pricing | jq -r '.freeModels[]'
```

## Tools

Tool calls are billed by their own unit, not by tokens:

| Tool             | Unit               | Price  |
| ---------------- | ------------------ | ------ |
| Web Search       | per call           | $0.002 |
| Code Interpreter | per session minute | $0.03  |
| File Storage     | per GB/month       | $0.20  |
| Image Generation | per image          | $0.04  |
| Speech-to-Text   | per minute         | $0.006 |
| Text-to-Speech   | per 1M characters  | $15.00 |
| Web Fetch        | per call           | $0.001 |

## What you are actually charged

A token is roughly three quarters of a word, so a 2,000-token prompt is
about three pages. Divide the rate by a million and multiply:

```
cost = (input_tokens x input_rate + output_tokens x output_rate) / 1_000_000
```

You never have to trust that arithmetic. Every response to
`/v1/chat/completions` carries a `usage` object counting exactly what was
billed:

```json
{
  "usage": {
    "prompt_tokens": 2000,
    "completion_tokens": 500,
    "total_tokens": 2500
  }
}
```

Where a model publishes a cache-read rate, tokens served from cache are
billed at that lower rate instead of the input rate — the catalogue shows it
per model as `cacheRead`.

## Read the rates programmatically

The page you are reading is generated from this endpoint, so it can tell you
nothing the endpoint will not:

```bash
curl -s https://api.hanzo.ai/v1/models | jq '.data[] | select(.id | test("^(hanzo/)?enso")) | {id, pricing}'
```

It needs no key. `/v1/pricing` returns the Hanzo family, the third-party
rates, the free-model list, the tool table, and the provider breakdown in one
document; `/v1/models` returns the same rates alongside the model ids you
pass as `model`.

## Next

- [Models](https://docs.hanzo.ai/docs/models): The live catalogue — every model id and its current rate.
- [Enso](https://docs.hanzo.ai/docs/models/enso): The Enso tiers: what each costs, cached tokens included, and the models behind it.
- [API keys](https://docs.hanzo.ai/docs/api-keys): Mint the key these requests are billed against.
- [Pricing API](https://docs.hanzo.ai/docs/openapi/pricing): Every pricing endpoint, generated from the spec.

_Per-token rates read from `/v1/models`. Everything else captured from `/v1/pricing` on 2026-10-30._