Claude Code Max vs API vs Qwen: 4h Breakeven

Every “Claude Code pricing” post I have read gives you a monthly total. Fifty bucks, two hundred bucks, whatever the sticker says. That total is fine right up until the moment you actually use the tool, at which point the sticker stops predicting anything, because the shape of your day is doing more work than the plan is.

I logged one week of Claude Code use — hour by hour, not month by month — and the answer to “which plan wins?” changed depending on which day I looked at. The breakeven between $200 Max, the metered Sonnet API, and my own RTX 4070 running Qwen3-35B-A3B does not sit at a single volume. It sits at a usage-hours-per-day curve, and the crossover moved by roughly four hours between my lightest day and my agent-orchestrator day.

This is the sibling piece to my three-way monthly cost breakdown and the 47-PR head-to-head with Codex. Those two answered “what’s the sticker” and “which agent.” This one answers the question I had to answer to actually make my monthly bill stop moving: which structure is cheapest at how many hours per day?

Why the monthly number is the wrong frame

The monthly-total framing hides a thing that shows up on the first day of real use: plans are not linear. Max 5x and Max 20x bill in weekly quotas that reset on a fixed cadence. The API bills per token. My local rig bills nothing until I turn it on, and then it bills electricity plus amortization whether I use it or not.

Those three things do not respond to “hours of use per day” the same way.

• API: perfectly linear. Every hour you use it costs the same as the last hour, modulo cache hits.
• Max plan: a fixed weekly ceiling. Zero marginal cost right up until you hit the cap, at which point cost jumps to your time, spent waiting for the reset window.
• Local: the hardware cost is fixed, so cost-per-hour drops the more hours you actually keep the GPU busy.

Put those on the same axis and they cross each other twice on the same day. That is the shape monthly totals paper over.

The three cost structures, in dollars-per-hour

Here are the pricing inputs I used, all from vendor pages as of September 2026. Verify these before you copy the numbers — Anthropic revised its programmatic-usage rules in June and the community-reported weekly hour caps on Max are approximate (intuitionlabs.ai).

Metered API — Sonnet 4.6, cache on. $3 per million input tokens, $15 per million output. My agent sessions burn ~500K–1M tokens per hour of actual driving, at a 70/30 input/output split. With prompt caching at 60%, that lands at $1.80–$3.60 per active hour. Opus 4.7 is ~1.7x that on per-token pricing ($5/$25), and its new tokenizer produces ~30% more tokens for the same content — the per-hour number lands closer to $4–$8 if you sit on it.

Max 20x, $200 flat. Community-reported quotas point to somewhere in the range of 240–480 Sonnet hours per week (userightai.com). Call it 35 usable Sonnet hours per day if you spread evenly, less if you burn in bursts and hit the 5-hour session reset. Amortized: $0.28 per hour at the low end, effectively $0 until you cap out.

Local Qwen3-35B-A3B on RTX 4070. From my own repo, that box does 34.6 tok/s warm with the --cpu-moe flag — 2.8x what Ollama defaults get on the same card. Amortized over 3 years at a $600 street price, the card is $0.55 per active hour. Power at 200W under load, at my JP rates ($0.30/kWh), adds ~$0.06/hour. Idle is ~$0.03/hour. Total when driven: ~$0.61/hour. But this is a fixed cost that keeps ticking whether you use it or not.

Those three numbers do not compare directly, because “$0.61/hour local” assumes you already own the card and use it enough hours to amortize it. That is exactly why hour-of-day matters.

The three days I actually logged

I want to walk through three days from last week. Same me, same repo, wildly different curves.

Day A — light day, ~2 hours of Claude Code

Tuesday. Two 45-minute driving sessions plus some scattered small edits. Total: ~2 active hours.

• API metered: 2h × ~$2.70 avg = $5.40
• Max 20x amortized to this day: $200/30 = $6.67
• Local Qwen amortized to this day: $0.61 × 2h + fixed daily amortization ($0.61 × 24 / days you’d actually use it) ≈ effectively $1.22 in marginal cost, but the sunk-cost card is doing nothing the other 22 hours. If your only day this week looks like Tuesday, local is buying you a $2,000 space heater.

Winner: API metering, by a large margin. On a 2h/day pattern, Max 20x is a $200 subscription that you use 60 hours a month; you would pay $180 on the API for the same hours and have the extra headroom for a spike.

Day B — daily-driver day, ~6 hours of Claude Code

Wednesday. One long refactor session across four files, three PR reviews, a debugging trace on a flaky test. Total: ~6 active hours.

• API metered: 6h × ~$2.70 avg = $16.20. Extrapolated across 30 days: $486/month. That is the point where you feel it.
• Max 20x amortized: still $6.67/day. Zero marginal cost per hour. You have not hit the cap; you have maybe 4 hours of headroom left before the 5-hour session reset.
• Local Qwen: $0.61 × 6h = $3.66 in run cost, plus amortization. If Wednesday is your median day, the card pays itself off. But the quality gap on the refactor is real — I benchmarked 100 tasks on this same setup, and complex refactors were where local lost consistently.

Winner: Max 20x, comfortably. This is the volume the plan is designed for. The API answer is technically feasible but you are paying a $470/month premium for the same output.

Day C — agent-orchestrator day, ~12 hours of Claude Code

Thursday. I turned on a cron harness that fans out five claude -p workers overnight to draft, factcheck, and lint queued articles, and then drove interactively for a chunk of the afternoon. Total: ~12 hours of actual model time, only ~4 of which was me typing.

Here is where the crossover moves.

• API metered: 12h × ~$3.20 avg (heavier output share) = $38.40. Extrapolate: $1,150/month. The claude -p cron pattern especially blows past the sticker because programmatic sessions post-June-15 draw from a dedicated credit pool billed at API rates (duet.so).
• Max 20x: you will hit the weekly Sonnet cap somewhere on Thursday night. The plan is still $200 for the month, but the effective cost is waiting for reset, which is the most expensive tier of compute.
• Local Qwen: $0.61 × 12h = $7.32 in run cost. Suddenly the amortization argument works: at 12h/day the card is being used enough that it pays off in ~4.2 months, matching my measured breakeven.

Winner: hybrid. Max 20x for the interactive 4 hours, local Qwen for the 8 hours of cron work where the model is grinding through mechanical batch tasks and I do not need frontier quality. Doing everything on the API costs $30/day extra. Doing everything on Max caps out mid-week.

The crossover shifts by four hours

Stack the three days and one thing pops out: the plan that wins at 2h/day is not the plan that wins at 6h/day, and neither wins at 12h/day. Between light and heavy, the breakeven shifts by roughly four hours of daily use.

This table is why “which one is cheapest?” is the wrong question. The right question is “which one is cheapest at the shape of my Tuesday?”

What I actually did after logging the week

Two things.

First, I stopped trying to make one structure cover all three days. My current setup: Max 20x for interactive daytime, local Qwen for cron-driven bulk work (drafting, lint, factcheck runs), and the metered API on standby for the occasional Opus 4.7 heavy refactor that neither of the other two can touch. Combined cost across last month: ~$215, versus the $486 that a Sonnet-API-only setup would have cost at my Wednesday volume alone.

Second, I moved my claude -p cron jobs off the Max credit pool and onto the local box wherever the task tolerates a 34.6 tok/s model. That single move cut ~$60/month out of the pool line item and freed up interactive headroom. The tasks that still need Sonnet quality — refactors, review of anything touching auth — stayed on Max.

If you take one thing from this: log a week of hours, not a month of dollars. The dollars are downstream. The hours-per-day pattern is the input, and that is the number the plan copy on every vendor page hides behind a flat total.

What I am watching for the rest of 2026

• Anthropic tightening or loosening the weekly hour caps on Max. Community-reported figures have shifted with each cap adjustment; treat any specific hour count as approximate (truefoundry.com).
• DRAM prices normalizing — the $600 4070 line moves the local column noticeably if it drops to $450, less if it stays where it is.
• The next Qwen release closing the quality gap on refactors specifically. Right now that is the one task type where local loses consistently, and the day it stops losing is the day the 12h/day column tips further toward hybrid.

Read pricing pages once a quarter. It takes 20 minutes and it will beat any general “which plan is best” post by a factor of your own weekly time log.

---

If you want the operating framework this thinking comes from — how to design, budget, and drive AI agent harnesses — I wrote a 19-chapter book on it: Harness Engineering — From Using AI to Controlling AI.