Claude Opus 5.5 for SEO and Google Ads: The Price Fell, the Effort Dial Now Sets the Bill

The benchmarks and the savings use different settings

Near the bottom of Anthropic's announcement for Claude Opus 5.5 is a line most launch coverage skipped: "Unless otherwise noted, all Claude Opus 5.5 results use adaptive thinking at max effort." Earlier in the same post, the company says its tests show the model "at default settings" costs 40% less than Opus 5 on typical workloads. On Opus 5.5 the default is medium effort. The benchmark scores and the savings were measured with the dial in different places.

Anthropic says both things plainly. The line still deserves attention from anyone running SEO, AI search visibility or Google Ads work on the model, because on Opus 5.5 effort is now the main thing you pay for. Thinking can no longer be turned off; a request that tries gets an error back. What you run on the model, and how hard you let it think, will move your bill more than the price cut does.

The argument of this piece is that Opus 5.5 earns its price on long, multi-step jobs where an early mistake spoils later steps, run against numbers that code has already computed. Anything with a right answer, from summing an Ads export to checking what a negative keyword blocks, should stay in code. Labeling thousands of rows belongs on a smaller model, or on a different kind of model entirely.

The headline scores are real gains on Anthropic's own runs. On Terminal-Bench 4.0, an agentic coding test, it reports 66.4% for Opus 5.5 against 52.3% for Opus 5 and 55.8% for Fable 5.1, its more expensive flagship. On AutomationBench it reports 40.0% against 26.9% for Opus 5. Those are max-effort numbers on the vendor's own test setup. Treat them as the direction of travel, and plan your costs around the setting you will actually use.

What shipped, and what it costs per token

Anthropic's pricing page lists Opus 5.5 at $4 per million input tokens and $20 per million output tokens. Cache reads cost $0.20 per million, which is 5% of the input price; most Claude models charge 10%. Writing to the five-minute cache costs $5 per million, and to the one-hour cache $8. The Batch API halves the base rates to $2 and $10. Fast mode, a research preview available only on Anthropic's own API, costs $8 and $40.

The model page gives a 1 million token context window, billed at the standard rate across the whole window, and up to 128,000 output tokens per request. Anthropic puts 1 million tokens at roughly 555,000 words on its current tokenizer, and the same pricing page notes that the tokenizer introduced with Opus 4.7 produces about 30% more tokens for the same text than older models did. If your cost estimates for a client were built on a 2025 model, they undercount.

Anthropic says Opus 5.5 "performs at the level of Claude Fable 5.1 on most work", and Fable 5.1 costs $10 and $50. Opus 5.5 is on the Claude API, Amazon Bedrock, Google Cloud, Microsoft Foundry and Claude Platform on AWS under the ID claude-opus-5-5, and the Claude Code changelog shows version 2.1.280 making it the default Opus model. Sonnet 5.5 and Haiku 5.5 follow "in the coming weeks", according to Anthropic. Until they arrive, the smaller current models are Sonnet 5 at $2 and $10 and Haiku 4.5 at $1 and $5.

The release notes list four breaking changes against Opus 5. Two touch search pipelines directly. Thinking is always on, and thinking: disabled now returns a 400 error. Forced tool use is gone too: setting tool_choice to any or to a named tool also returns a 400. Plenty of classification scripts force a "label" tool call to get clean JSON back, and those scripts will fail the moment someone changes the model ID. Anthropic's documented fix is to leave tool_choice on auto and set strict: true on the tool, or to move the schema to structured outputs.

What a 500-page audit costs

Take a common agency job as a worked example: read 500 pages of a client site and write a specific fix for each page that needs one. Say each page is about 3,000 tokens of cleaned text and structure going in, and about 400 tokens of findings coming out. That is 1.5 million input tokens and 200,000 tokens of visible output. The table is list-price arithmetic on those assumptions.

Two rows matter more than the price cut. The first is batch. An audit nobody needs back within the minute should not run at list price, and on this job the Batch API saves twice what the new pricing does.

The second is the thinking row. The 1,200 tokens per page is an assumption, not a measurement; the real figure depends on the page and the effort level. But Anthropic's thinking documentation is explicit that reasoning tokens "are billed as output tokens, even when the thinking text isn't returned to you", and output costs five times as much as input. A modest amount of thinking more than doubles this job. The price cut saved $2.50 here. An effort level nobody chose on purpose can cost several times that, and the docs add that at a given effort level Opus 5.5 "tends to think more per turn" than Opus 5.

Then there is caching, the cheapest lever in the release. Say every call carries the same 4,000-token rulebook: your severity scale, the client's brand rules, the output format. Uncached, 500 calls spend 2 million input tokens, $8, on instructions, which is more than the pages themselves cost. Cached, the reads come to $0.40 plus a two-cent write. The cache lasts five minutes, or an hour at the higher write price, refreshes on each hit, and needs a prompt of at least 512 tokens.

None of these totals is large. A full-site read of a mid-size client costs less than an hour of anyone's time at every setting in the table. The expensive outcome is a wrong change reaching a live site.

Jobs worth the big model

Pay for Opus where one decision depends on many earlier ones and a mistake in step three quietly ruins step nine.

Site-wide changes in a codebase

Fixing a title template across a Next.js or WordPress theme, rewriting internal links after a restructure, adding structured data to every product template, building a redirect map for a migration. These are coding jobs with search consequences, and they run in Claude Code against the real repository. Anthropic's launch post quotes unnamed early testers: one "completed a 680,000-line code migration in less than a day"; another reports auditing and fixing a 200,000-line codebase in under three hours where Opus 5 took more than 20. These are anecdotes the vendor chose to publish. The part that transfers to a client site is that long, multi-file jobs are where the model's gains show up.

Diagnosis across sources

Say a page lost a third of its clicks. Was it a title change on the last deploy, a newer page on the same site competing for the same queries, a paid campaign that started bidding on them, or a reporting change in Search Console? Answering means holding a crawl, a Search Console export and an Ads export at once and reasoning across them. A 1 million token window holds all three for most sites. Let code do the join first, so the model reasons over one clean table instead of reconciling three raw files.

Search terms judgement

For a Google Ads account, the valuable question about a wasted search term is why it wasted. It may be off-topic and safe to block. It may be on-topic, with the landing page failing the searcher. Or conversions across a whole campaign may have stopped on the same day, which points to a broken tag rather than bad terms. That is judgement, and Opus 5.5 is good at it when it is handed figures it did not compute itself.

Explaining results to a client

A report that says in plain words what changed, what it did, and what happens next. The model writes the explanation well. It should not produce the numbers inside it.

Where code should make the call

A cheaper, stronger model makes it tempting to hand it the whole CSV. Resist that for three kinds of work, because each has a right answer that a script gets every time and a model gets most of the time.

Totals and rates

Spend, CTR, conversion rate, clicks lost since a change. Google Ads report downloads typically carry summary rows labeled Total, and a model summing a column will sooner or later add the totals to themselves. Blank and dash cells mean missing, not zero, and a model has to be told that every time; a parser is told once. Compute every figure in a script and pass the model the result.

What a negative keyword blocks

Google's Ads Help documentation on negative keywords says negatives "don't match to close variants", so a negative shoe does not block shoes; you add the plural and synonyms yourself. A negative broad match blocks a search containing all its words in any order, a negative phrase match blocks the words in that order, and a negative exact match blocks only that exact search with no extra words. Those rules are deterministic. A model can propose negatives, but code should test each one against every search term in the export, including the ones that converted, and list what it would block before anyone adds it.

Whether a term has spent enough to judge

Twelve clicks and no conversions looks like waste. If the account converts one click in 50, the chance of seeing zero conversions from 12 clicks is 0.98 multiplied by itself 12 times: about 78%. A term performing exactly at the account average would show zero most of the time at that volume. The threshold for calling waste depends on the account's own rate, and that is a formula, not a judgement. Run it in code, and give the model only the terms that cross it.

Labeling at volume belongs elsewhere

Tagging 20,000 search terms by intent, or 5,000 URLs by page type, is a decision with a fixed set of answers repeated thousands of times. On Opus 5.5 every one of those calls carries some thinking, because thinking cannot be disabled. Anthropic's effort documentation recommends low for "simpler tasks that need the best speed and lowest costs", and says the model can skip thinking on simple problems at lower levels. That helps. It still leaves you paying Opus rates for work that does not need Opus judgement.

Haiku 4.5 at $1 and $5, or Sonnet 5 at $2 and $10, will label most of these rows well, and Haiku 5.5 is due within weeks. A decision model such as TypeSafe's Jev, which returns one of a set of answers you define, with a confidence score, at $0.042 per million input tokens and no charge for output, is built for exactly this shape of job. Whichever you pick, check its labels against a few hundred rows you labeled yourself before you let it route anything.

How it prices against GPT-6 Sol and Luna

OpenAI released GPT-6 Sol and GPT-6 Luna on the same day. Its developer documentation lists Sol at $2 per million input tokens, $0.20 cached and $10 output, and Luna at $0.10, $0.01 and $0.50. Both have a 1.05 million token context window and 128,000 output tokens. Per token, Sol costs half of Opus 5.5 and the same as Anthropic's own Sonnet 5.

Per-token prices compare badly across vendors. Tokenizers differ, so the same page is a different number of tokens on each, and models differ in how much they think per task. Each vendor also reports benchmarks on its own test setup. The only figure that means anything for your work is cost per finished job at acceptable quality, measured on a week of your own tasks. For most search teams the answer will be a split rather than a winner: a frontier model for the agentic, multi-step work, a small model or a decision model for labels and first drafts, and code for every number.

What to change before you switch

1. Set effort explicitly on every call. A request that omits it runs at medium on Opus 5.5, one level below the high default it ran at on Opus 5. Run the same 20 real jobs at two or three levels and compare quality and cost before choosing.
2. Remove thinking: disabled and any forced tool_choice from your scripts. Use auto with strict tool use or structured outputs for JSON.
3. Move anything that can wait to the Batch API, and cache the instructions every call repeats.
4. Keep counting in code: parse exports, drop summary rows, treat missing as missing, test every negative against the full term list.
5. Measure every change against a control group of untouched pages, or a good month for the whole site gets credited to your change. See how to prove an SEO change worked.

AIO Copilot is built on the same split: code does the arithmetic and shows its working, the model drafts, and a person presses apply. The free Ads leak check runs the negative keyword part on a search terms export without touching the account. The app runs the whole method every week; get started and we email pricing and the setup steps.

API model IDs are pinned snapshots, so no script changed on its own on 22 September (Claude Code's Opus setting did). But every script someone points at claude-opus-5-5 without an effort parameter will run one level lower than it did the day before, and every one that forced a tool call will stop working. Check both before the first client job runs on it.

Frequently Asked Questions