Claude API Pricing: How Much It Really Costs (and How to Cut It)

Claude API pricing is simple on paper: pay per million tokens, by model. What is not simple is knowing whether the model and settings you picked six months ago are still the cheapest way to hit your accuracy bar. Anthropic's September 8, 2026 blog post, "Reducing cost and improving performance with Claude Platform", addresses exactly that gap with a new Claude Code command: /claude-api hillclimb. It searches for a cheaper model, effort level, and prompt configuration for you, without you having to guess.

This article covers both halves of the question: what Claude API pricing actually looks like today, and how hillclimb helps you spend less against it without a manual trial-and-error process.

What Claude API Pricing Looks Like Today

Claude API pricing is charged per million tokens (MTok), split between input and output tokens, and it varies by model:

• Claude Opus 5: $5 / MTok input, $25 / MTok output
• Claude Sonnet 5: $2 / MTok input, $10 / MTok output
• Claude Haiku 4.5: $1 / MTok input, $5 / MTok output

Anthropic also offers prompt caching (cheaper rates for cached reads and writes) and batch processing (roughly half price for workloads that can tolerate asynchronous processing). The gap between Opus 5 and Haiku 4.5 output pricing alone is 5x, which is exactly why model choice is the single biggest lever on your bill, bigger than any individual prompt tweak. Effort level is the other big lever, and it interacts with model choice in ways covered in our breakdown of Claude Code Ultracode.

The catch is that picking the cheapest model rarely works on its own. Drop from Opus to Sonnet or Haiku without changing anything else and accuracy usually falls with it. That tradeoff, model versus effort versus prompt versus accuracy, is what hillclimb is built to search through automatically.

How the /claude-api hillclimb Command Works

hillclimb is documented in Anthropic's blog post rather than in the published CHANGELOG.md, which makes the post itself the primary record that Claude Code gained this feature. It ships inside Claude Code's built-in claude-api skill, so there is no separate install: any developer building on the Claude API can run it directly. If you want to go beyond this one command, our How to Master Claude Code series covers the rest of Claude Code's built-in skills and commands.

It joins two commands that were already part of that skill:

• cost-optimize profiles an existing codebase's Claude API spend and shows where the money is going.
• prompt-audit flags outdated prompting patterns, things like verification rituals, mandatory tool-call steps, and scratchpad instructions written for older, weaker models that no longer need that scaffolding.
• hillclimb runs an actual search. Given an evaluation set, it splits your test cases into a training set and a held-out test set, then works through model, effort, and prompt configurations, reading the training examples that fail at each step to decide what to change next.

The held-out split matters. It is what keeps the optimizer from simply overfitting to the examples it has already seen: the configuration it finally reports is scored on tickets it never touched during tuning.

A Worked Example From Anthropic

Anthropic ran hillclimb against an internal customer-support benchmark, and the numbers show how the search actually plays out.

Starting point: Opus 4.8 at its default high-effort setting.

Step one, hillclimb tried Opus 5 at low effort, combined with prompt-audit's cleanup of mandatory tool-call rituals and scratchpad steps. That matched the original 98.9% training accuracy at 2.6 cents per ticket, a fraction of the starting cost.

Step two, it tried stepping down further to Sonnet 5 at low effort. Cost dropped again, to 1 cent per ticket, but accuracy fell to 88.9%.

Step three, hillclimb read the newly failing tickets and added routing rules plus a refund-cap cross-reference to the prompt. That recovered the original 98.9% accuracy at the Sonnet 5, low-effort price point.

On the 14 held-out tickets the search never saw during tuning, the final configuration scored 90.5%, against 78.6% for the untouched original setup, at roughly one-fifth the cost. That is the core promise: not just a cheaper model, but a cheaper configuration that was actually tested for accuracy before you trust it in production.

How to Use It on Your Own Codebase

Before you run hillclimb, it helps to plan the evaluation itself with the same discipline you would use to plan a feature before you build it. The practical shape of the workflow, per Anthropic's description, is:

1. Have (or write) an evaluation for the Claude API call you want to tune, with enough examples to split into train and test sets.
2. Run /claude-api hillclimb inside Claude Code, pointed at that evaluation.
3. Let it search model, effort, and prompt changes, reading failures to decide what to try next.
4. Review the final configuration and its held-out score before shipping, the same way you would review any change from a teammate.

Because it builds on prompt-audit and cost-optimize, the fastest path in is often to run all three in order: find where the spend is concentrated, strip the prompt of anything written for an older model, then let hillclimb search the remaining space.

Claude API Pricing Tuning for Product Managers

If you are a PM rather than the engineer writing the Claude API calls, hillclimb still changes what you can credibly ask for. A few places it shows up in PM work:

• Cost review in a spec. When an engineer proposes "we'll use Opus for this," you now have a concrete follow-up: has hillclimb been run against an eval for this feature, and what did the held-out score look like at a cheaper configuration?
• Vendor and build-vs-buy comparisons. Knowing that a 5x price gap between models does not automatically mean a 5x accuracy gap changes how you weigh a Claude API feature against a flat-fee third-party tool, the same kind of tradeoff we break down in Claude Code vs Cursor pricing.
• Roadmap sequencing. A feature that looked too expensive to ship at Opus pricing might clear the bar once someone runs the cost-optimize to hillclimb pipeline on it, which is a cheap thing to check before killing an idea in planning.

None of this requires you to write the eval or run the command yourself, but knowing the tool exists means you can ask for the number instead of accepting a shrug when someone says "the API costs too much."

Product manager and want to work like this? This is exactly what we teach in Claude Code for PMs, our live cohort for product teams: 3 live sessions of 90 minutes over 2 weeks. Every PM ships a real feature, builds their own agent, and gets personalized written feedback.

Claude API Pricing vs. Claude Code Token Usage

It is worth separating two related but different questions. Claude API pricing, the topic of this article, is about what you pay when your own code calls the Claude API directly: per-token rates by model, tuned through tools like hillclimb. Claude Code token usage is a different scope: it is about the habits that drive your token consumption inside the Claude Code CLI itself, as a developer using Claude interactively at your terminal. If you are building a product on the Claude API, this article is your starting point. If you are trying to get more out of your own Claude Code sessions day to day, that one is.

The Takeaway

Claude API pricing rewards teams that treat cost as something to measure, not something to guess at. Opus 5, Sonnet 5, and Haiku 4.5 give you a real range to work with, $5 to $1 per million input tokens, $25 to $5 per million output tokens, and /claude-api hillclimb gives you a way to find the cheapest point in that range that still holds your accuracy bar, backed by a held-out test rather than a hunch. Pair it with prompt-audit and cost-optimize, and the whole toolkit turns "our API bill is too high" from a complaint into a testable question.