Usage and Billing

Every successful response reports token usage, including streaming responses. Use it to track spend per request. For account-level usage and cost over time, use the usage API or the dashboard at app.wafer.ai.

Chat Completions usage

curl -sS "https://pass.wafer.ai/v1/chat/completions" \
  -H "Authorization: Bearer <YOUR_WAFER_API_KEY>" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "GLM-5.3",
    "messages": [{"role": "user", "content": "What is 17 * 3?"}],
    "max_tokens": 512
  }'

The response carries a usage object:

{
  "usage": {
    "prompt_tokens": 4508,
    "completion_tokens": 20,
    "total_tokens": 4528,
    "prompt_tokens_details": {"cached_tokens": 4352},
    "completion_tokens_details": {"reasoning_tokens": 16}
  }
}

Field	Meaning
`prompt_tokens`	All prompt tokens, including cached tokens.
`prompt_tokens_details.cached_tokens`	Prompt tokens served from the prompt cache. A subset of `prompt_tokens`.
`completion_tokens`	All generated tokens, including reasoning tokens.
`completion_tokens_details.reasoning_tokens`	Generated tokens spent on returned reasoning. A subset of `completion_tokens`. On `GLM-5.3` and `GLM-5.3-Flash` with reasoning set to `none`, reasoning that isn’t returned is counted in `completion_tokens` but not here; see the reasoning warning.
`total_tokens`	`prompt_tokens + completion_tokens`.

Successful streams end with a usage chunk before data: [DONE]. You don’t need to set stream_options. See Streaming.

Responses usage

/v1/responses returns usage.input_tokens, usage.output_tokens, and usage.total_tokens. output_tokens includes reasoning tokens. input_tokens_details.cached_tokens is included when there are cached tokens, and non-streaming responses can include output_tokens_details.reasoning_tokens. In streams, usage is on the response.completed event.

Messages usage

/v1/messages returns usage.input_tokens, usage.output_tokens, usage.cache_read_input_tokens, and usage.cache_creation_input_tokens. In streams, final usage is on the message_delta event.

On Wafer, input_tokens counts all prompt tokens, including cache_read_input_tokens. Anthropic’s own API excludes cached tokens from input_tokens. Subtract cache_read_input_tokens from input_tokens to get uncached prompt tokens. cache_creation_input_tokens is always 0: Wafer has no separate cache-write charge.

Prompt caching

Prompt caching is automatic. When a request starts with the same tokens as a recent request, Wafer reuses the cached prefix. You don’t need to send cache_control or any other field. Cached tokens are reported as prompt_tokens_details.cached_tokens (Chat Completions), input_tokens_details.cached_tokens (Responses), or cache_read_input_tokens (Messages), and bill at the cache-read rate. Cache hits aren’t guaranteed. To get more cache hits, keep the stable part of the prompt (system prompt, tool definitions, long documents) at the start and put changing content at the end.

How requests are billed

Serverless is prepaid. Each request is charged against your credit balance at the rates in the model’s wafer.pricing card (see Pricing):

Uncached prompt tokens (prompt tokens minus cached tokens) at input_microcents_per_million when present, otherwise input_cents_per_million.
Cached prompt tokens at cache_read_microcents_per_million.
Generated tokens, including reasoning tokens, at output_microcents_per_million when present, otherwise output_cents_per_million.

Each of the three amounts is rounded to the nearest microcent (one millionth of a cent) per request, with halves rounded up. On some models, generated tokens can exceed max_tokens when reasoning is on; see Output length. Call GET /v1/models with your API key to see your account’s rates. Without a key, the cards show list prices. Requests rejected before generation starts (authentication, validation, and rate-limit errors) are not charged. A stream that fails after it starts may be charged for tokens already generated. /v1/messages/count_tokens is free. Before a request runs, Wafer checks that your balance covers its maximum possible cost. When it doesn’t, Wafer returns 402 with code insufficient_credits. See Credits.

Dynamic pricing

Dynamic pricing is optional. When an account owner or admin turns it on in the Dynamic pricing card on the Billing page at app.wafer.ai, some models are billed at Wafer’s market price instead of the standard price. A dynamic price can be above or below the standard price, and changes whenever Wafer’s market pricing does. Each request is billed at the price in force when it arrives. Models without a dynamic price stay at the standard price. The Billing card lists today’s dynamic prices next to the standard prices, and GET /v1/models with your API key shows the rate your account pays. Turning dynamic pricing off takes effect immediately. Wafer Pass plan usage isn’t affected, and accounts with negotiated prices keep them.

Account usage API

GET https://api.wafer.ai/v1/usage returns your account’s requests, tokens, and billed cost over time. Authenticate with any API key on the account. The report covers every key on the account for that key’s endpoint.

curl -sS "https://api.wafer.ai/v1/usage?starting_at=2026-09-01&ending_at=2026-10-01&bucket_width=1d" \
  -H "Authorization: Bearer <YOUR_WAFER_API_KEY>"

Parameter	Meaning
`starting_at`	Required. Start of the window: an RFC 3339 timestamp or a `YYYY-MM-DD` date (UTC).
`ending_at`	End of the window, exclusive. Defaults to the end of the current bucket.
`bucket_width`	`1d` (default, up to 93 buckets) or `1h` (up to 168 buckets). `starting_at` and `ending_at` must fall on a UTC day or hour boundary to match.
`group_by`	`model` (default) or `api_key`.

The response has one entry in data per bucket, including empty ones, and totals for the whole window. This excerpt of the response to the request above shows only the first of its 30 daily buckets, so totals is larger than that one bucket:

{
  "object": "usage_report",
  "bucket_width": "1d",
  "group_by": "model",
  "cost_status": "billed",
  "currency": "usd",
  "totals": {"requests": 1520, "input_tokens": 9120000, "cache_read_tokens": 6100000, "output_tokens": 412000, "cost_usd": 3.418},
  "data": [
    {
      "starting_at": "2026-09-01T00:00:00Z",
      "ending_at": "2026-09-02T00:00:00Z",
      "requests": 52,
      "input_tokens": 310000,
      "cache_read_tokens": 205000,
      "output_tokens": 14000,
      "cost_usd": 0.1137,
      "results": [
        {"model": "GLM-5.3", "requests": 40, "input_tokens": 280000, "cache_read_tokens": 190000, "output_tokens": 12000, "cost_usd": 0.0981},
        {"model": "DeepSeek-V4.1-Flash", "requests": 12, "input_tokens": 30000, "cache_read_tokens": 15000, "output_tokens": 2000, "cost_usd": 0.0156}
      ]
    }
  ]
}

input_tokens includes cache_read_tokens, as in per-request usage.
cost_usd is what each request was charged at your account’s rates, before invoice-level discounts or credits. Cost history starts on 2026-06-16; earlier buckets report cost_usd as null.
Cost is tracked per model, not per key. With group_by=api_key, each key’s cost_usd is null; the bucket and window totals still include cost.
Usage under a model name that can’t be shown is grouped under unavailable.
cost_status is billed when cost is reported, not_applicable for plans that aren’t billed per token, and unavailable when cost can’t be reported for this account (contact support).
Tokens are bucketed by request time and cost by billing time, so daily figures near midnight UTC can differ slightly. The most recent minutes may not be included yet.

Dashboard

The dashboard at app.wafer.ai shows your credit balance and usage, and is where you add credits. To track individual requests, use the usage object in each response and the x-request-id response header to correlate requests with your logs.