Claude API vs Subscription: which one cheap?

Claude API cheaper than subscription be?

Claude API cheaper pass subscription if you no use am too much, but if you use am plenty, e go cost pass. For developer wey dey code interactively all day, flat plan dey usually win. For program wey dey make its own calls, API na the only option, so cost no be the main thing. The rest na arithmetic wey you fit do inside ten minutes.

No official break-even number dey for anywhere. Subscription side dey sell usage windows instead of token allowances, so no published figure fit tell you where the two lines cross. Wetin follow na the formula, based on current per-token rates, plus the way you dey use am wey fit change the answer pass the plan fee. Every break-even figure wey dey below na my own arithmetic from published rates and assumptions, no be documented number.

If you still dey decide which plan to buy, which Claude plan fits the way you work go answer that one. This post assume say you don know which plan you wan buy, and you just wan know if you suppose buy am at all.

Two billing models wey no be the same shape

Subscription na capacity wey you fit no use. You pay fixed fee and you get allowance wey dey reset on schedule. Anthropic Claude Code documentation talk the shape for Team and Enterprise seats: usage "draws from a per-seat allowance that resets on a rolling five-hour window and a weekly window", wey Claude chat and Cowork dey share. Subscriber go see the same shape through the messages wey dem hit, wey dey read "You've hit your session limit" and "You've hit your weekly limit". Capacity wey you no use na money wey you don spend anyway. Capacity wey you exceed go stop your work until the window reset, and switching model with /model no go restore access, because the windows dey shared across models.

API na meter wey no dey stop. No window and no wall dey. Every request dey cost per token, and some things dey cost outside tokens: web search "is available on the Claude API for $10 per 1,000 searches". Nothing dey stop at a limit. The invoice just dey grow.

Plan fees as of 23 July 2026, from Claude pricing page: Pro na "$17 Per month with annual subscription discount ($200 billed up front). $20 if billed monthly", and e include Claude Code. Max dey list as "From $100 Per month". Team seats start at "$20 Per seat / month if billed annually". Enterprise na the interesting one, because e dey run both models at once: "Seat price + usage at API rates $20/seat". The fees dey change often, and the allowance behind each one no dey published in tokens, so read the pricing page for the day you decide.

Wetin you no fit get from the API

A plan allowance, and the interface wey dem build around am. Claude Code /usage-credits command dey manage subscription usage credits, and you run am "after signing in with your claude.ai subscription through /login; the command isn't available with API key authentication." The /usage screen also different by billing mode: its Session block "shows API token usage and is intended for API users", while subscribers dey see plan usage bars and usage breakdown instead.

A longer prompt cache for Claude Code. This one cost real money and e easy to miss. The documentation talk say "The lifetime is an hour on a subscription and drops to five minutes once you're drawing on usage credits; on an API key or cloud provider, it's five minutes by default". Your first message after you take break longer than the cache lifetime go miss the cache, so your whole context go reprocess and dem go bill you at write prices. On a subscription, you fit take fifty-minute meeting and come back warm. On an API key, the same break go cost full re-write of the session prefix.

Wetin you no fit get from a subscription

Programmatic access. A cron job or a webhook handler wey dey call Claude need API key, so if that na your workload, the comparison don end. Building your first Claude API app on a VPS cover how to handle key and the first working script.

The Batch API discount. The pricing page talk am clearly: "The Batch API allows asynchronous processing of large volumes of requests with a 50% discount on both input and output tokens." That one dey halve the meter for any work wey human no dey wait for. Batch rates per million tokens na $2.50 for input and $12.50 for output on Opus 4.8, $1 and $5 on Sonnet 5 for introductory pricing, and $0.50 and $2.50 on Haiku 4.5. The trade-off na latency: most batches dey finish inside one hour, any batch wey no finish within 24 hours go expire, and streaming no fit be batched. Batch and prompt caching fit stack, and because a batch fit run longer than five minutes, use the 1-hour cache inside one.

Per-project cost attribution. Every API response dey return usage block, so you fit log the cost of one single request and tie am to one project or customer. A subscription dey report one set of bars for the person wey hold the seat.

Make I tell you one thing carefully, because e easy to assume for any side: these na separate billing surfaces. Anthropic documentation dey route subscription billing to claude.ai support and Console billing to the API platform, and /usage-credits no dey work under an API key. Nothing wey I check say a subscription include API credit, so plan for two accounts and two bills.

The break-even formula

Price one turn, then scale am.

turn cost = uncached_input_tokens x base_input_price
          + cache_write_tokens    x 1.25 x base_input_price
          + cache_read_tokens     x 0.10 x base_input_price
          + output_tokens         x output_price

monthly API cost = turn cost x turns_per_active_day x active_days_per_month

break even when: monthly API cost = flat plan fee

The multipliers dey published, dem no be estimates. A 5-minute cache write cost "1.25x base input price", a 1-hour write cost "2x base input price", and a cache read cost "0.1x base input price". Thinking tokens dey bill as output tokens, so dem belong for output_tokens even for models wey no dey show reasoning summary.

Base rates per million tokens (MTok), current on 23 July 2026:

• claude-fable-5: $10 input, $50 output. Cache read $1. 5-minute cache write $12.50. 1M context.
• claude-opus-4-8 and claude-opus-4-7: $5 input, $25 output. Cache read $0.50. 5-minute cache write $6.25. 1M context.
• claude-sonnet-5: $2 input, $10 output on introductory pricing through 31 August 2026, then $3 and $15. At introductory rates, cache read $0.20 and 5-minute cache write $2.50. 1M context.
• claude-haiku-4-5: $1 input, $5 output. Cache read $0.10. 5-minute cache write $1.25. 200K context.

No extra charge for long context: "A 900k-token request is billed at the same per-token rate as a 9k-token request."

One worked example, with the assumptions wey we write down

Take one mid-session Claude Code turn on Sonnet 5 wey carry 60,000 tokens of context: 55,000 from cache, 3,000 newly written to cache, 2,000 tokens of fresh uncached input, and 1,200 output tokens including thinking.

• Cache reads: 55,000 x $0.20/MTok = $0.0110
• Cache writes: 3,000 x $2.50/MTok = $0.0075
• Uncached input: 2,000 x $2.00/MTok = $0.0040
• Output: 1,200 x $10.00/MTok = $0.0120

That one na about $0.035 per turn. At 120 turns for one active day, roughly $4.14 a day. At 20 active days for month, roughly $83 a month.

Compare that with the flat fees wey dey above, e dey tell you two things at once. E dey about four times the Pro fee, so Pro cheaper for paper, if its allowance fit carry 120 Sonnet turns for day. That condition na wetin no published number fit settle for you. The same $83 dey below the entry Max fee, so for here, meter beat Max.

Now change one assumption at a time, and watch how the plan fee go stop to be the deciding number.

Three things wey dey move the break-even more than the plan price

Prompt caching. Run the same 60,000-token turn without caching and the whole prompt go bill as fresh input: 60,000 x $2.00/MTok = $0.12, plus $0.012 of output, so $0.132 per turn. That one na nearly four times the cached turn, and e go turn the $83 month into about $317. This na the one break-even wey Anthropic dey publish, because e no depend on your workload: "A cache hit costs 10% of the standard input price, which means caching pays off after just one cache read for the 5-minute duration (1.25x write), or after two cache reads for the 1-hour duration (2x write)."

Two failure modes dey switch caching off without tell you. The first na prefix wey short pass the model minimum cacheable length: 512 tokens on Fable 5, 1,024 on Opus 4.8 and Sonnet 5, 2,048 on Opus 4.7, and 4,096 on Haiku 4.5. Shorter prefix no dey cache, and no error go come out. The second na parallel requests, because "a cache entry only becomes available after the first response begins." Ten identical requests wey dem fire at once all go pay full input price. The sign for both na cache_read_input_tokens dey sit at zero.

Model choice. Price the same turn on Opus 4.8, at $5 in and $25 out, with cache reads at $0.50 and 5-minute writes at $6.25 per MTok: reads $0.0275, writes $0.0188, uncached input $0.0100, output $0.0300. That one na about $0.086 per turn, 2.5 times the Sonnet turn, and about $207 a month at the same volume. One model choice move the same work from below the entry Max fee to more than twice am. Haiku 4.5 at $1 and $5 move am the other way for mechanical work like log triage.

Effort level belong to model choice, because thinking tokens dey bill at output rates. On Opus 4.8 the API default na high, and the documented starting point for coding and agentic work na the costlier xhigh. Lower am with /effort for Claude Code or with output_config.effort for the API. One more thing shift old estimates: the newer models dey use newer tokenizer wey "produces approximately 30% more tokens for the same text", so a count wey dem measure for older model go understate the same text today.

Session hygiene. The API dey stateless, so every turn dey re-send the whole conversation as billed input. Long session therefore cost more per message than fresh one, wey na the mechanism behind most surprise invoices and e dey explain for detail for what actually consumes tokens in a Claude Code session. Run /clear between unrelated tasks, because stale context dey re-sent and re-billed for every later message. Run /compact inside one long task, so history go summarize instead of carry am full. Work in continuous stints, because the default cache "has a 5-minute lifetime" and "is refreshed for no additional cost each time the cached content is used". A session wey you touch once every ten minutes dey pay a re-write every time. A detached Claude Code session running in tmux on a VPS dey spend almost nothing while e dey idle, but idling pass the cache lifetime still dey lose the warm prefix.

Measure your own usage before you decide

No decide from my example. Decide from one week of your own.

For Claude Code, run /usage at the end of each session for one week (/cost na an alias for the same screen). E dey report the session token counts and cost estimate, with one caveat from the documentation: "The dollar figure is an estimate computed locally from token counts and may differ from your actual bill." Totals dey reset when you run /clear, so read the screen first. On a subscription, that dollar figure no be your bill, but the token counts behind am na wetin this formula need. /context show wetin dey fill the window.

For an API account, the usage page for the Claude Console na the real record. To price one prompt before you send am, client.messages.count_tokens() na "free to use but subject to requests per minute rate limits based on your usage tier", and na the only count wey dey use the tokenizer wey dem go actually bill you under.

After a call, read the usage block, and read am correctly:

u = response.usage
total_input = u.input_tokens + u.cache_creation_input_tokens + u.cache_read_input_tokens

input_tokens count only the uncached remainder, wey dem document as the "tokens after the last cache breakpoint". A turn wey report input_tokens: 4000 no be a 4,000-token turn, and the three fields wey dem add together na the prompt size wey this formula want.

Then compare. If your measured month land clearly below the plan fee, take the meter. If e land clearly over, take the plan, as long as its allowance carry normal working day for you. If e land near the line, take the plan, because a plan no fit surprise you and a meter fit.

FAQ

Is the Claude API cheaper than Claude Pro or Max?

E depend on volume, and no published break-even dey to look up, because subscriptions dey sold as usage windows instead of token allowances. Price one typical turn from the published per-token rates, multiply by your turns per active day and active days per month, then compare that figure with the plan fee. In one worked example, a 60,000-token Sonnet 5 turn come to about $0.035, or roughly $83 a month at 120 turns a day over 20 days: above the Pro fee, below the entry Max fee.

How do I work out my Claude API cost per month?

Run /usage for Claude Code for one week to collect real token counts, or read the usage page for the Claude Console if you don't already hold an API account. Then price one turn: uncached input at the base rate, cache writes at 1.25 times base input, cache reads at 0.1 times base input, and output at the output rate, counting thinking tokens as output. Multiply by turns per active day and active days per month.

What changes a Claude API bill the most?

Prompt caching, more than anything else. A 60,000-token turn on Sonnet 5 cost about $0.035 when the prefix dey come from cache and about $0.132 when e no dey. Model choice follow next: the same turn on Opus 4.8 cost about $0.086. Session length follow third, because the API dey stateless and every turn dey re-send the whole conversation as billed input.

Does a Claude subscription include API access?

Treat them as two accounts with two bills. API calls dey bill per token against an account wey you create for the Console, and nothing for the documentation wey I check say a subscription dey grant API credit. The clearest sign say dem be separate surfaces na Claude Code /usage-credits command, wey "isn't available with API key authentication". Many developers hold both: a plan for interactive coding, a key for the things dem dey build.