# Claude Code Pricing — What You're Actually Paying For ☕️

> Source: <https://dev.to/maksymsokolov/claude-code-pricing-what-youre-actually-paying-for-479p>
> Published: 2026-09-23 18:13:05+00:00

Most developers are asking "how do I use fewer tokens?"

The better question is: **how does the price actually form?** Because once you understand that, you'll stop bleeding money in ways you didn't even know were happening.

There are 4 token types — and they're not priced equally.

*(Using Claude Sonnet 4.6 as our baseline)*

**① Input tokens — 1×**

Everything Claude reads: your messages, file contents, MCP tools, CLAUDE.md, system prompts. Your baseline cost.

**② Output tokens — 5×**

Everything Claude writes back. ~5× more than input. But here's the sneaky part: **that output becomes input on the next turn.** Every token Claude generated gets re-sent as context in your next message. Bloated responses compound across a session.

**③ Cache write tokens — 1.25× or 2×**

When Claude caches your context, you pay a write premium — paid upfront, and again every time the cache expires and gets rewritten. The exact cost depends on which TTL tier you're on (more on that below).

**④ Cache read tokens — 0.1×**

*This is where the magic lives.* Reading from cache costs **10× less** than fresh input. That gap is what makes Claude Code economically viable for large codebases.

There are **two cache durations** — and they have different write prices:

| TTL | Write cost | Read cost | 
|---|---|---|
| 5 minutes | 1.25× base | 0.1× | 
| 1 hour | 2.00× base | 0.1× | 

Both TTLs read at the same cheap 0.1× rate. The difference is only at write time.

The 1-hour write costs 60% more per token than the 5-minute write. That premium only pays off if you actually reuse the cache across a gap longer than 5 minutes — otherwise you paid extra for nothing.

**Which one you get depends on how you run Claude Code:**

So if you're on the API path, the coffee-break penalty is *far more acute*. A 6-minute pause that costs a subscriber almost nothing can trigger a full rewrite for an API user.

**The TTL is rolling, not fixed from session start.** Every cache hit resets the clock. Stay active and the cache stays warm indefinitely. The danger isn't a single long pause — it's not knowing the clock is ticking at all.

Go quiet past your TTL? The cache expires. Your next message triggers a full **cache rewrite** — that's a **12.5× price jump** for 5m cache, and **20× for 1h cache**, compared to a simple cache hit.

For Opus 5 at 200k context, a single 1h cache rewrite costs **~$2.00**. Keeping it warm costs **~$0.10**. That's per turn — let the cache expire three times in one session and you've spent $6.00 just on rewrites, without shipping a single extra feature.

Miss enough cache windows in one session and you can double your bill without shipping a single extra feature.

These actions force a full cache rewrite — even mid-session:

`/compact`
Each one blows away the warm cache and starts the write cycle again.

**① Enable notifications**

Open `/config` inside Claude Code and set **Notifications** to match your terminal (terminal bell, iTerm2, Ghostty, or Kitty). Claude pings you the moment it finishes, so you step away *after* it responds, not during. Come back, send the next prompt, cache stays warm.

**② Add a status line**

Claude Code supports a live status line in your terminal showing context size, cost, and cache hit rate. Watching that number drop is the earliest signal your TTL is about to expire — before the expensive rewrite hits.

**③ Run `/usage`**

Shows a full breakdown of token consumption including cache hits, cache writes, input and output. Helps you spot if you're bleeding money on rewrites without realizing it.

| Token Type | Cost | When it triggers | 
|---|---|---|
| Input | 1× | Every turn, fresh content | 
| Output | 5× | Everything Claude writes | 
| Cache write (5m TTL) | 1.25× | API default — first write, or after expiry | 
| Cache write (1h TTL) | 2.00× | Subscriber default — pays off across longer gaps | 
| Cache read | 0.1× | Every turn within TTL (same for both tiers) | 

Cache is your biggest lever. Writing it costs a little. Reading it costs almost nothing. Letting it expire costs you both.

Stay in the window. Use notifications. Don't change your model mid-session without a reason.

**Go make your coffee. Just come back before the clock runs out. ☕🙃**

*What's your current Claude Code cost per active day? Drop it in the comments — curious where people land.*