Claude API vs OpenAI API: Price and Features

At matching tiers the two APIs cost the same. OpenAI's GPT-6.1 Sol and Anthropic's Sonnet 5.5 are both $2 per million input tokens and $10 per million output tokens. GPT-6 Astra and Claude Fable 5.1 are both $10 and $50. Anthropic's Opus 5.5 sits between them at $4 and $20. The differences that matter are cache pricing, speed tiers, context behavior and tooling, covered below. Read on 31 October 2026.

The short version

The model lineups

Anthropic

All prices are per million tokens. Haiku 5.5 has two input tiers on the pricing page: $0.10 for prompts up to 100K tokens and $0.50 for longer prompts, so "from" means the short-prompt price.

OpenAI

OpenAI's page has a Short and Long context toggle. The prices above are for the default view, which we read as short context.

OpenAI's guidance: start with Astra for complex reasoning and coding, choose Sol to balance intelligence and cost, and Luna for cost-sensitive high-volume work. Anthropic's guidance is to start with Opus 5.5 for most workloads and use Fable 5.1 when Opus at higher effort still falls short.

Reading them together

The four tiers match in structure: a flagship, a near-flagship, an efficient middle, and a small model. The flagship prices are identical. The near-flagship prices match in the case of Sol and Sonnet, while Opus 5.5 is a separate step between Sonnet and Fable. Luna and Haiku start at the same low rates.

Because list prices match, a price comparison on its own does not decide anything. What decides is how many tokens each model spends on your task and how many retries it takes. Both vendors say their newer models use fewer tokens per task than their predecessors, but neither page compares itself to the other, and we did not measure either.

Cache, batch and speed tiers

Prompt caching

Cached reads cost five percent of the input price on both. OpenAI lists two cache-write durations, 30 minutes and 12 hours, with the longer one at twice the price. Anthropic's table lists a single cache-write price per model.

Anthropic says Sonnet 5.5 offers up to 90 percent cost savings with prompt caching. For an agent that resends a long system prompt and tool list on every turn, caching is usually the biggest lever on your bill.

Batch

Anthropic says batch processing saves 50 percent. OpenAI's Batch prices are half of Standard on the models we read: Astra $5 and $25, Sol $1 and $5, Terra $0.50 and $2.50, Luna $0.05 and $0.25. OpenAI groups this as Flex/Batch. The trade is latency: batch is for work that can wait.

Faster tiers

OpenAI sells speed as an upgrade. The Fast tier doubles the standard rate (Astra $20 and $100, Sol $4 and $20), and the Ultrafast tier is shown for Astra at $60 and $300 and Sol at $12 and $60. Anthropic's equivalent is fast mode for Opus 5.5, in Claude Code and on the Claude Platform, at up to 2.5x faster, priced at $8 input and $40 output, which is twice standard Opus.

Regional handling

OpenAI charges a 10 percent uplift on regional processing (data residency) endpoints for models released on or after March 5, 2026, and the same for FedRAMP endpoints. Anthropic offers US-only inference at 1.1x pricing for input and output tokens on its newer models. The structure is the same.

Where each model runs

Anthropic lists its current models on four routes in addition to its own API: Amazon Bedrock, Google Cloud (both Google managed and Anthropic managed), Microsoft Foundry and Claude Platform on AWS. Each has its own model ID format, such as anthropic.claude-sonnet-5-5 on Bedrock.

OpenAI lists its models through the Responses API and client SDKs. Whether a given OpenAI model is on a third-party cloud is outside what we read.

This matters if your company has committed spend with a cloud provider. A model you can buy through that commitment may be cheaper in practice than a cheaper list price you pay by card.

Features beyond price

Thinking and effort. Anthropic's current models use adaptive thinking, which is always on for Fable and Opus. Defaults differ: Opus 5.5 and Haiku 5.5 default to medium effort, Fable 5.1 and Sonnet 5.5 to high. OpenAI lists reasoning levels, from low to max for Astra and Sol, and none to max for Terra and Luna. Both let you set it, and both charge for thinking tokens as output.

Tools. OpenAI lists functions, web search, file search and computer use for all four. Anthropic says all current models support tool use, and its model API reports whether a model accepts server tools such as web search and code execution.

Interfaces. OpenAI's models are available through the Responses API. Anthropic has the Messages API and its Platform, plus SDKs.

Lifecycle. Anthropic publishes retirement dates: Fable 5.1 not sooner than September 1, 2027, Opus 5.5 September 22, Sonnet 5.5 September 28 and Haiku 5.5 October 7, 2027. OpenAI's pricing and Codex pages show models rotating faster; for example, Codex with ChatGPT sign-in retired GPT-5.5 on October 14, 2026, while API use was unaffected.

Knowledge cutoff. Anthropic lists June 2026 for all four. OpenAI lists April 30, 2026 for Astra and Sol, June 1, 2026 for Terra and May 18, 2026 for Luna.

What a bill looks like

A worked example, using only list prices. Say an agent makes 1,000 calls a day, each with 20,000 input tokens (of which 18,000 are a repeated cached prefix) and 1,500 output tokens, on a $2 and $10 model.

• Uncached: 20M input tokens at $2 is $40, plus 1.5M output tokens at $10 is $15. Total $55 a day.
• With a cached prefix: 2M uncached input is $4, 18M cached reads at $0.10 is $1.80, and output stays $15. Total about $20.80 a day, plus cache writes.

Cache writes add a little, since the first call writes the prefix. The point is the shape: output dominates once input is cached, so a model that writes shorter answers can matter more than its input price. That arithmetic is identical on both APIs at these tiers. Replace the numbers with your own traces before budgeting.

Data handling and terms

Both vendors say that API customers are treated differently from consumers. Anthropic's data-usage page says that for the API and third-party platforms, commercial terms apply and Anthropic does not train generative models on code or prompts sent to Claude Code under those terms, unless the customer opts in, for example through the Developer Partner Program. That page is about Claude Code, so check the API terms for your own use.

Google, for comparison, marks its paid Gemini API tier as "not used to improve our products." We bring that up as a pattern: ask each vendor the same three questions before you send customer data. What is retained, for how long, and is any of it used for training? Is there a zero-retention option? Where is it processed?

Limits and quotas

Per-token price is only half of an API bill. Rate limits decide whether you can run the job at all. Both vendors scale limits with spend tiers or account level, and both publish the tables in their docs, which we did not read for this page. If you plan a launch, ask for limit increases a week early, and test at your expected peak before you promote the feature.

Choosing

Choose Anthropic when:

• You want the Claude models, for example because your coding agent is Claude Code.
• You buy through Amazon Bedrock, Google Cloud or Microsoft Foundry and want the same IDs there.
• You value published retirement dates a year out.

Choose OpenAI when:

• You want the GPT-6 family, or Codex's models.
• You need an upgrade path to faster tiers (Fast, Ultrafast) priced in the same table.
• Your stack already uses the Responses API.

Use both when:

• You route by task: a small model for classification, a flagship for hard cases. Because the price ladders match, routing by quality instead of by cost is a clean experiment.

Moving between them

Switching vendors is mostly an interface and evaluation job, not a price job. Plan three steps: map your tool definitions to the other API's format, rerun your evals on the same prompts, and re-tune thinking effort, since defaults differ. A gateway or router service can hide the interface difference, at the cost of one more vendor. See OpenRouter alternatives for that route.

A short checklist

• Count tokens on a real trace before you compare prices.
• Turn on caching for repeated prefixes.
• Use batch for anything that can wait.
• Check your cloud commitment before choosing a vendor.
• Set effort explicitly on both.
• Write down the date you read the prices. They change.

The same workload across tiers

Take the bill example above: 1,000 calls a day, 20,000 input tokens and 1,500 output tokens each, so 20M input and 1.5M output tokens a day, uncached. Only the model changes. All rates are the list prices from the tables above.

Haiku's $0.10 rate applies to prompts up to 100K tokens, and these prompts are 20K, so the short-prompt price holds. The spread between the top and bottom rows is 100 times. That is why routing matters more than which vendor you pick: if a small model handles most of your calls acceptably, the vendor choice moves your bill by cents, and the model choice moves it by hundreds of dollars.

Two discounts stack on the middle row. Half-price batch brings the uncached Sonnet or Sol figure to $27.50 a day, if your work can wait. A cached prefix brings it to about $20.80 a day. We do not give a combined figure, because the pages we read do not say whether batch and caching discounts combine on each vendor.

What to check before you commit to one API

1. Where your cloud commitment sits. Anthropic's models are listed on Bedrock, Google Cloud, Microsoft Foundry and Claude Platform on AWS. If your spend is committed to one of those clouds, buy through it.
2. How your prompts are shaped. A long repeated prefix favours whichever cache you can hit most reliably. Check both vendors' cache-write rules against your call pattern.
3. How long a model will exist. Anthropic lists retirement dates, the earliest of which is 1 September 2027 for Fable 5.1. OpenAI's Codex page showed GPT-5.5 retired for ChatGPT sign-in on 14 October 2026, though the API was unaffected. Put a model-migration day on your calendar.
4. What your SDK abstracts. If you write against one vendor's request shape, switching costs a rewrite of tool schemas and message formats. A thin adapter of your own, or a gateway such as the ones in our OpenRouter alternatives, keeps that cost down.
5. Which limits you hit first. Ask for higher rate limits before launch.

A two-day evaluation plan

Day one: collect fifty real requests from your logs, with the answers you accepted. Strip secrets. Run all fifty on one model from each vendor at the same price tier, and keep the outputs.

Day two: have someone who did not run them grade the outputs blind, against the answers you accepted. Record the pass rate, the average output tokens and the cost per passing answer. Then repeat the run on the next tier down. The row where the pass rate stays acceptable and the cost per passing answer is lowest is your starting model. Do not trust a leaderboard to do this for you, because your prompts are not its prompts.

Our take

Going by the vendors' own tables, this is a tie on price and a contest on fit. The ladders were built to mirror each other, down to $2 and $10 in the middle and $10 and $50 at the top. What separates them is the cloud routes, the speed tiers and the model behavior in your workflow, and only the last one needs a test.

If you are starting a project, build against the vendor whose agent tooling you already use, keep your prompts portable, and run the same eval on the other one once. We did not run model evaluations for this page. The numbers here are list prices, read on 31 October 2026, and both vendors have changed prices before.

Related

• ChatGPT vs Claude
• ChatGPT vs Claude vs Gemini
• Claude Opus vs Sonnet
• Compare AI models
• OpenRouter alternatives
• How we compare