Credits and the formula
1 credit = $0.01 of usage at list price, and 100 credits cost $0.15. The credits deducted for a request are its cost at Anthropic's USD list prices, multiplied by 100.
How "15% of list price" is calculated
$1 of usage at Anthropic's list prices is 100 credits on OpusVIP, and 100 credits cost you $0.15. $0.15 ÷ $1 = 15%, so you pay 15% of list price for the same usage. Credits are always deducted at USD list prices.
A request's charge is the sum of four items, each at its own price (credits per 1M tokens):
- Input: input tokens that were neither read from nor written to the cache.
- Cache write: tokens written to the cache for the first time, with a 5-minute or a 1-hour lifetime.
- Cache read: tokens sent again within the cache lifetime and served from the cache. This is the cheapest rate.
- Output: tokens the model generates.
The examples below use Claude Opus 5.5 (claude-opus-5-5). Prices per million tokens: input 400 credits, output 2,000 credits, cache read 20 credits, cache write 500 credits (5-minute) or 800 credits (1-hour). These are the USD list prices (input $4, output $20, cache read $0.20, 5-minute cache write $5) multiplied by 100. Token counts in the examples are illustrative, not measurements.
A concrete case: if a Claude Code task would cost $0.90 at list price, it deducts 90 credits, which cost you $0.135.
Example 1: the first request
The first turn in Claude Code writes the system prompt and project context to the cache. Assume this turn has 2,000 input tokens, 30,000 cache-write tokens (5-minute) and 1,500 output tokens. Credits per item = tokens × credits per million ÷ 1,000,000.
| Item | Tokens | Credits / 1M | Credits charged |
|---|---|---|---|
| Input | 2,000 | 400 | 0.80 |
| Cache write, 5-minute | 30,000 | 500 | 15.00 |
| Output | 1,500 | 2,000 | 3.00 |
| Total | 18.80 credits |
The total is 18.80 credits, which is $0.1880 at list price; you pay $0.0282.
Example 2: the next turn, with a cache hit
The next turn arrives within the cache lifetime, so the earlier 30,000 tokens of context are read from the cache. Assume 800 input, 2,500 cache-write, 30,000 cache-read and 1,200 output tokens.
| Item | Tokens | Credits / 1M | Credits charged |
|---|---|---|---|
| Input | 800 | 400 | 0.32 |
| Cache write, 5-minute | 2,500 | 500 | 1.25 |
| Cache read | 30,000 | 20 | 0.60 |
| Output | 1,200 | 2,000 | 2.40 |
| Total | 4.57 credits |
The total is 4.57 credits, which is $0.0457 at list price; you pay $0.00686.
What happens without caching
Take the same request as Example 2, but price all the context as regular input (33,300 input tokens in total). It would cost 15.72 credits, about 3.4 times the 4.57 credits with caching. A cache read costs only 5% of regular input, which is why caching saves the most in long sessions. Whether a request hits the cache depends on how the client structures its prompt; Claude Code uses caching by default.
How to verify a charge
The usage log in the console lists every request with its model, input, output, cache-write and cache-read token counts, and the credits charged. To recompute a row, multiply each of the four token counts by the price above, divide by 1,000,000, and add them up; the result should match the credits charged. Divide by 100 for the USD list price, then multiply by 0.15 for what you paid. Failed requests are never billed.