# Claude Sonnet 5.5 vs GPT-6.1 Terra: 2x per Token, 2–10x per Task

> GPT-6.1 Terra lists at half Claude Sonnet 5.5's price, and Sonnet counts 1.43x the tokens on English, so below 272K the same tasks bill 2–10x more on Sonnet.

- URL: https://blog.laozhang.ai/en/posts/claude-sonnet-5-5-vs-gpt-6-1-terra
- Published: 2026-11-03
- Updated: 2026-11-03
- Author: LaoZhang AI Team (https://blog.laozhang.ai/en/about)
- Topic: Model Comparisons
- Tags: Claude Sonnet 5.5, GPT-6.1 Terra, model comparison, API pricing, Claude API, OpenAI API

---
If you pay for Claude Sonnet 5.5 and want a smaller bill, move high-volume work you can check, such as chat, extraction, summaries, writing, image reading and single-turn coding with tests, to `gpt-6.1-terra` at its default `medium` effort. Keep `claude-sonnet-5-5` for multi-step terminal agents, tool-heavy automation and office-document work, where it still scores ahead at the same overall level, and for anything that needs more than Terra can reach. GPT-6.1 Terra, released October 26, 2026, lists at $1 per million input tokens and $5 per million output tokens, half of Sonnet 5.5's rates. In a same-prompt test on November 3, 2026, Sonnet at `high` cost 2.84x as much as Terra at `medium` for the same 12 tasks, with 11 of 12 passing on Sonnet and 12 of 12 on Terra.

Half the price turns into less than half the bill because Sonnet counts more tokens. For the same English text, Sonnet 5.5 counted 1.43x as many input tokens as Terra, so the same English input bills about 2.9x. On Artificial Analysis's Intelligence Index v5.0, as of November 3, 2026, Terra scores at or above Sonnet at each effort name up to `high`, and Sonnet costs 4.6–10.4x more per task across the five shared effort names. Only Sonnet at `max` scores above the best Terra setting.

Two conditions shrink or stretch that ratio. Above 272K input tokens Terra's price per token doubles for the whole request while Sonnet's stays flat to 1M, so the gap falls to roughly the token ratio, about 1.4x for English. Terra also caches repeated prefixes on its own, while Sonnet caches only when the request carries `cache_control`, so an agent loop that resends a long prefix without it costs 15–21x as much on Sonnet. Before switching, run 10–20 of your own prompts on both and compare cost per accepted answer.

## Which work moves to GPT-6.1 Terra and which stays on Sonnet 5.5

Move work to Terra when a cheap check tells you whether the answer is right, and keep Sonnet where it still leads at the same score: long terminal sessions, automation across tools and office documents. That split follows the per-benchmark results on Artificial Analysis (AA) as of November 3, 2026, and it matches what OpenAI's [GPT-6.1 Terra announcement](https://openai.com/index/introducing-gpt-6-1-terra/) says the model is built for: fast, efficient visual reasoning, computer use and clear writing.

| Kind of work | Start with | What would change it |
| --- | --- | --- |
| Chat, extraction, summaries and writing at volume | Terra `medium` | Your checks catch errors on Terra that Sonnet doesn't make on the same inputs |
| Single-turn coding you can test: functions, parsers, scripts | Terra `medium`, then `high` for the failures | A test still fails on Terra `high` but passes on Sonnet |
| Reading screenshots and images, computer use | Terra | Your own runs show Sonnet clearly ahead on your screens |
| Science and hard-reasoning questions | Terra `max`, through the Responses API | Terra `max` gets the same questions wrong that Sonnet gets right |
| Multi-step terminal agents, automation across tools, office documents | Sonnet `xhigh` or `max` | Terra `max` passes your own agent runs at a fraction of the cost |
| The hardest tasks, where Terra `max` still falls short | Sonnet `max`, or a larger model | Sonnet `max` takes the longest of any setting here; for the most complex coding OpenAI points to GPT-6.1 Sol or GPT-6 Astra |
| Prompts above 272K Terra tokens | Whichever passes your checks | Price is no longer the deciding factor, because the gap narrows to the token ratio |

If you chose Sonnet for its $2/$10 price tier, GPT-6.1 Sol charges the same per token, and [Claude Sonnet 5.5 vs GPT-6.1 Sol: Same Price, 2–8x Cost per Task](https://blog.laozhang.ai/en/posts/claude-sonnet-5-5-vs-gpt-6-1-sol) covers that pairing. [GPT-6.1 Terra vs GPT-6.1 Sol: Half the Price, Not Always Cheaper](https://blog.laozhang.ai/en/posts/gpt-6-1-terra-vs-gpt-6-1-sol) covers when Sol beats Terra on cost inside OpenAI's own lineup, and [GPT-6.1 Terra vs GPT-6 Luna: 10× per Token, 2.7–6.3× per Task](https://blog.laozhang.ai/en/posts/gpt-6-1-terra-vs-gpt-6-luna) covers the cheaper step down. OpenAI's own launch comparison sets Terra against Claude Opus 5.5, not Sonnet, and its one-ninth cost-per-task claim at `max` is about Opus; [Claude Opus 5.5 vs GPT-6.1 Terra: 1/9 the Cost Only at Max](https://blog.laozhang.ai/en/posts/claude-opus-5-5-vs-gpt-6-1-terra) checks that claim.

## Claude Sonnet 5.5 vs GPT-6.1 Terra at each effort level (AA v5.0)

At the same effort name, Terra scores at or above Sonnet up to `high` and below it at `xhigh` and `max`, and it is cheaper per task at every one of them. These are the results on the [Artificial Analysis Sonnet 5.5 vs GPT-6.1 Terra release comparison](https://artificialanalysis.ai/models/releases/comparisons/claude-sonnet-5-5-vs-gpt-6-1-terra), Intelligence Index v5.0, as of November 3, 2026. AA runs each setting once, and its cost per task prices AA's own token mix at each vendor's list rates.

| Effort | Sonnet 5.5 Index | Sonnet cost per task | Sonnet time per task | Terra Index | Terra cost per task | Terra time per task | Sonnet ÷ Terra cost |
| --- | ---: | ---: | ---: | ---: | ---: | ---: | ---: |
| `none` (Terra only) | — | — | — | 30 | $0.23 | 104 s | — |
| `low` | 25 | $0.51 | 127 s | 29 | $0.07 | 48 s | 7.3x |
| `medium` | 30 | $0.78 | 190 s | 38 | $0.17 | 118 s | 4.6x |
| `high` | 41 | $1.64 | 344 s | 42 | $0.26 | 172 s | 6.3x |
| `xhigh` | 50 | $4.09 | 719 s | 45 | $0.40 | 248 s | 10.2x |
| `max` | 54 | $10.02 | 1,263 s | 51 | $0.96 | 533 s | 10.4x |

Effort names are not equal settings across vendors, so the fairer readings are default against default and score against score. Sonnet 5.5's default depends on where you use it: `high` on the Claude API, `medium` in Claude Code and the Claude apps, according to [Anthropic's Sonnet 5.5 announcement](https://www.anthropic.com/news/claude-sonnet-5-5). Terra's API default is `medium`. On the API, Sonnet's default costs 9.6x Terra's and takes 2.9x as long per task for 3 more Index points. In Claude Code, Sonnet's `medium` scores 8 points below Terra's `medium` at 4.6x the cost; [Claude Code Effort Level: Model Defaults and Why It Won't Stick](https://blog.laozhang.ai/en/posts/claude-code-effort-level) covers how Claude Code sets that default.

Matched by score, Sonnet `xhigh` (50) and Terra `max` (51) are the closest pair: Terra is one point higher at 4.3x lower cost and 1.35x less time per task. Lower down, Sonnet `medium` (30) costs 3.4x Terra with reasoning off (`none`, also 30) and 11.1x Terra `low` (29). Sonnet `max` at 54 is the only setting either model offers above 51, and it takes 2.4x as long per task as Terra `max`. On the gateway used for the test below, Terra's `max` was accepted only through the Responses API.

![Chart of AA Intelligence Index v5.0 against cost per task for Claude Sonnet 5.5 and GPT-6.1 Terra at each effort level, marking API defaults at 9.6x, the same-score pair at 4.3x and Sonnet max at 10.4x](https://blog.laozhang.ai/posts/en/claude-sonnet-5-5-vs-gpt-6-1-terra/img/effort-score-vs-cost.webp)

AA replaced Intelligence Index v4.3.2 with v5.0 around October 28, 2026, and every number moved. Figures such as a tie at 36 and 41 at `low` and `medium`, or a 52–45 Sonnet lead at `xhigh`, come from v4.3.2; under v5.0 the two models do not tie at any effort. The Index combines nine evaluations, including office work, automation, terminal tasks, coding, knowledge and science, so it is not a coding score on its own.

## Where Sonnet 5.5 leads at the same score: terminals, automation, office files

Compared at the same overall level, Sonnet at `xhigh` (Index 50) against Terra at `max` (51), Sonnet leads the three agentic and office benchmarks, and Terra leads FrontierCode, HLE-Diamond and the two science benchmarks. So the near-tie on the Index hides a real split by kind of work, and the split, not the Index, is what should decide where each job goes. Results are AA v5.0 as of November 3, 2026, from the same AA comparison page.

| AA v5.0 evaluation | Sonnet 5.5 `xhigh` (Index 50) | GPT-6.1 Terra `max` (Index 51) | Sonnet 5.5 `max` (Index 54) |
| --- | ---: | ---: | ---: |
| Terminal-Bench 4.0 | 57.1% | 55.6% | 63.6% |
| AutomationBench-AA | 65.5% | 60.2% | 71.8% |
| AA-Briefcase v1.1 (score) | 1,744 | 1,402 | 1,814 |
| HLE-Diamond | 44.1% | 47.3% | 53.3% |
| FrontierCode 2.0 | 35.6% | 42.3% | 41.7% |
| CritPt v2 (Hard) | 54.0% | 64.5% | 56.0% |
| Terminal-Bench-Science 0.1 | 52.4% | 57.6% | 53.3% |

Raising Sonnet to `max` widens its lead on terminal, automation and office work and takes HLE-Diamond, but it still trails Terra `max` on FrontierCode, CritPt and Terminal-Bench-Science. If your workload looks like those three, paying 10x more per task for Sonnet `max` buys a lower score. AA's sector indexes at the matched pair are close in most fields: Sonnet `xhigh` and Terra `max` tie in finance and accounting at 49, and differ by one or two points in legal, healthcare, engineering and economics; strategy and operations is the widest gap, 54 to 50 for Sonnet.

## Same 12 prompts on November 3, 2026: Sonnet cost 2.84x Terra medium

On November 3, 2026, the same 12 single-turn tasks with hidden tests or exact answers were sent to Sonnet 5.5 at `high` and to Terra at `medium` and `high`. Sonnet passed 11, Terra `medium` 12 and Terra `high` 11, so the tasks did not separate the models on quality, and the useful result is the cost: at vendor list prices applied to the usage each API returned, Sonnet cost 2.84x Terra `medium` and 2.12x Terra `high`.

The tasks were a word problem, an interval merger, a duration parser with 18 hidden tests, a word counter with 10, a five-bullet summary of an article of roughly 6,700 words with a 25-word limit per bullet, an expression evaluator with 25 tests, a CSV line parser with 16, a digit-sum count, semantic-version comparison with 30 tests, npm-style version ranges with 36, totals from three notes buried in a long document, and a question about made-up CPython functions that both models correctly said do not exist. Each task ran once per setting, as one user message with no system prompt and no tools.

| Setting | Passed | List-price cost | Input tokens | Output tokens (reasoning) | Sum of call times |
| --- | ---: | ---: | ---: | ---: | ---: |
| Sonnet 5.5, `high` | 11/12 | $0.178 | 33,300 | 11,155 (not reported separately) | 103 s |
| GPT-6.1 Terra, `medium` | 12/12 | $0.063 | 21,977 | 7,149 (3,740) | 130 s |
| GPT-6.1 Terra, `high` | 11/12 | $0.084 | 21,977 | 11,375 (7,816) | 176 s |

Both misses are the same format slip on the summary task: one bullet of 26 words against the 25-word limit. With one sample per task, that is noise rather than a ranking, and Sonnet made the identical slip in an earlier run of the same task on October 28. What the test does show is where the cost gap comes from. At `high` against `high` the two wrote almost the same number of output tokens, so the gap is the 2x unit price plus Sonnet's 1.52x input tokens on this mix of prompts. Terra at `medium` wrote fewer output tokens, which is why it was the cheapest setting. Per task, Sonnet cost 2.0–5.8x Terra `medium` and 1.1–4.0x Terra `high`.

Speed went the other way from AA. Through this route Sonnet was faster per call than Terra `medium` on 11 of 12 tasks and faster than Terra `high` on all 12, with median calls of 7.25 s, 8.75 s and 11.4 s. AA's time per task at `high` points the opposite way, 344 s for Sonnet against 172 s for Terra. That is a different measure on different tasks from per-call latency on these 12 prompts, so time both models on your own prompts and route rather than relying on either figure.

Terra also wrote to its cache without being asked. On the two prompts of about 10,100 tokens, Terra's usage reported 10,103 and 10,195 cache-write tokens with no cache settings in the request, priced at $1.25 per million instead of the $1 input rate. That 25% premium on long prompts pays off only if the same prefix comes back within the cache lifetime. Sonnet reported no cache activity, because no `cache_control` was sent.

The test ran through the LaoZhang API gateway (laozhang.ai) with one key and non-streaming requests: Sonnet on the Anthropic Messages endpoint with `thinking: {"type": "adaptive"}` and `output_config.effort` set to `high`, Terra on Chat Completions with `reasoning_effort` and `max_completion_tokens` of 32,000. Three route details matter if you repeat it. In checks on October 28, Terra on Chat Completions rejected `max_tokens` with HTTP 400 and asked for `max_completion_tokens`, and it rejected `reasoning_effort: "max"` (accepting `none` through `xhigh`) while `reasoning: {"effort": "max"}` on `/v1/responses` returned 200. Sonnet requests that left out `thinking` returned no thinking blocks in an October 26 check, so set it explicitly. Claude on LaoZhang caps a single output at 32,768 tokens, against 128K on Anthropic's API. Tools, multi-turn agents, images, the Responses API, direct vendor endpoints, and the other effort levels were not part of this run; for those, the AA results above are the reference.

*Disclosure: [laozhang.ai is our own service](https://blog.laozhang.ai/en/about#laozhang). Its prices are platform pricing, not an independent comparison.*

## Is half the price half the bill? Sonnet bills 2.3–2.9x on English

No. On the same work Terra's bill is usually less than half of Sonnet's, because the bill is unit price × token count × how much the chosen effort makes the model write, and Sonnet's tokenizer adds about 43% to English input before effort enters at all. Below 272K Terra tokens, English input alone comes to about 2.9x on Sonnet, and the worked cases below land between 2.3x and 2.8x once output is included. The list prices are the Standard API rates on [Anthropic's Claude pricing page](https://platform.claude.com/docs/en/about-claude/pricing) and [OpenAI's API pricing page](https://developers.openai.com/api/docs/pricing) as of November 3, 2026.

| Per 1M tokens, Standard tier | Claude Sonnet 5.5 | GPT-6.1 Terra, up to 272K input | GPT-6.1 Terra, above 272K input |
| --- | ---: | ---: | ---: |
| Input | $2.00 | $1.00 | $2.00 |
| Output, including reasoning | $10.00 | $5.00 | $7.50 |
| Cache read | $0.10 | $0.05 | $0.10 |
| Cache write | $2.50 (5-min), $4.00 (1-hour) | $1.25 (30-min), $2.50 (12-hour) | $2.50 (30-min), $5.00 (12-hour) |
| Batch input / output | $1.00 / $5.00 | $0.50 / $2.50 | — |

Both models take text and images, offer 128K tokens of output, and have a context window of about a million tokens: 1M for Sonnet 5.5 at standard pricing all the way, 1.05M for Terra. Sonnet's effort levels run from `low` to `max`, Terra's from `none` to `max`.

Token count is the multiplier the price table hides. On November 3, 2026, the same 6,000 characters of English counted 2,419 input tokens on Sonnet 5.5 and 1,688 on Terra, 1.43x, and a long English document came to 15,335 against 10,198, 1.50x. Python code came out at 1.46x. Other languages ranged from 1.30x for Japanese to 1.62x for Korean, so the same input text bills 2.6x to 3.2x on Sonnet below 272K depending on the language. Each figure is one passage per language, with the instruction-only baseline subtracted on both sides.

To estimate your own ratio, price each model on its own token counts:

```text
Per 1M tokens, each model's own counts
GPT-6.1 Terra (up to 272K input) = 1.00 × input + 5.00 × output + 1.25 × cache writes + 0.05 × cache reads
GPT-6.1 Terra (above 272K input) = 2.00 × input + 7.50 × output + 2.50 × cache writes + 0.10 × cache reads
Claude Sonnet 5.5 (up to 1M)      = 2.00 × input + 10.00 × output + 2.50 × cache writes + 0.10 × cache reads
Sonnet input tokens ≈ Terra input tokens × 1.43 for English text
```

The table runs that formula on a few typical shapes, with token counts given in Terra tokens and output kept equal on both sides.

| Case, in Terra tokens | GPT-6.1 Terra | Sonnet 5.5, same token count | Sonnet 5.5, English text |
| --- | ---: | ---: | ---: |
| One chat turn: 2K in, 500 out | $0.0045 | $0.0090 (2.0x) | $0.0107 (2.4x) |
| Document: 270K in, 5K out | $0.295 | $0.590 (2.0x) | $0.822 (2.8x) |
| Document: 280K in, 5K out | $0.598 | $0.610 (1.02x) | $0.851 (1.42x) |
| Agent loop, 50 turns: 100K cached prefix, 2K new and 1K out per turn | $0.72 | $1.44 (2.0x) | $1.84 (2.6x) |
| Same loop, Sonnet without `cache_control` | $0.72 | $10.70 (14.9x) | $15.09 (21x) |
| Batch: 10,000 requests of 3K in, 1K out | $40.00 | $80.00 (2.0x) | $92.90 (2.3x) |

![Sonnet 5.5 to GPT-6.1 Terra bill ratio on English text: 2x price times 1.43x tokens gives about 2.9x, worked cases land at 2.3–2.8x, prompts above 272K fall to 1.42x and an agent loop without cache_control reaches 21x](https://blog.laozhang.ai/posts/en/claude-sonnet-5-5-vs-gpt-6-1-terra/img/bill-ratio-cases.webp)

Output is where your own numbers will differ most. The table holds output equal, which matched the test at `high` against `high`, but Sonnet at `high` wrote 1.56x the output tokens of Terra at `medium`. If you compare Sonnet's current setting against Terra's default, multiply the output side by your own output ratio as well, and the bill ratio moves toward the wider gap seen in the test against Terra `medium`.

## Above 272K tokens or without cache_control, the ratio moves

Two settings move the ratio far from 2–3x: very long prompts pull it down toward the token ratio, about 1.4x for English, and an uncached Sonnet agent loop pushes it past 15x. Both come from the published pricing rules as of November 3, 2026, not from model quality, so they can change your decision even when both models pass your checks.

Above 272K input tokens, OpenAI prices the whole Terra request at the long-context rates: $2 input, $7.50 output, and doubled cache rates. Sonnet 5.5 keeps its standard rates up to its full 1M window. Once a prompt crosses the line, input costs the same per token on both, Terra's output is still cheaper, and the gap is mostly Sonnet's extra tokens: 1.42x for the 280K English document above, against 2.8x at 270K. The line is counted in Terra tokens, and 272K Terra tokens of English is about 389K Sonnet tokens; going the other way, Sonnet's 1M window holds about 700K Terra tokens' worth of English. The cliff also matters inside Terra alone, because the 280K document costs twice the 270K one, so trimming a prompt just under 272K halves its Terra cost.

Caching is the larger swing, and it is opt-in on one side only. Anthropic caches Sonnet prompts only when the request carries `cache_control`, either as a top-level field that sets the breakpoint automatically or as explicit breakpoints, according to the [Claude prompt caching docs](https://platform.claude.com/docs/en/build-with-claude/prompt-caching). Without it, every turn of an agent loop pays full input price for the whole history. OpenAI caches Terra automatically and bills the writes, as the test above showed. In the 50-turn loop, adding `cache_control` cuts Sonnet's English bill from $15.09 to $1.84, a bigger saving than moving the cached loop to Terra at $0.72, so check your Sonnet requests for `cache_control` before you compare bills. Sonnet's default cache lives 5 minutes against Terra's 30, so a loop with long pauses between turns caches less on Sonnet unless you pay for the 1-hour write.

## Sonnet 5.5 vs Terra 5.6: which Terra are you comparing?

The Terra released on October 26, 2026 is GPT-6.1 Terra, model ID `gpt-6.1-terra`, and there is no `gpt-6-terra` ID. GPT-5.6 Terra (`gpt-5.6-terra`) is the previous Terra and is still live: as of November 3, 2026, its [OpenAI model page](https://developers.openai.com/api/docs/models/gpt-5.6-terra) lists $2 input and $12 output per million tokens with a February 16, 2026 knowledge cutoff, and the [OpenAI deprecations page](https://developers.openai.com/api/docs/deprecations) gives it no shutdown date. Against that older Terra, Sonnet 5.5 costs the same for input and less for output, so none of the cost ratios on this page apply to it. The same goes for the older Claude Sonnet 5: every figure here is for Sonnet 5.5, and [Claude Sonnet 5.5 vs Sonnet 5: Cost by Effort and What Breaks](https://blog.laozhang.ai/en/posts/claude-sonnet-5-5) covers what changes if you are still on Sonnet 5. [GPT-6 Sol vs Terra vs Luna vs Astra: Which Model Should You Use?](https://blog.laozhang.ai/en/posts/gpt-6-sol-vs-terra-vs-luna-vs-astra) explains where each Terra sits in OpenAI's lineup.

## Using Terra in ChatGPT or Codex and Sonnet in Claude plans

In ChatGPT, GPT-6.1 Terra is available in Work and Codex, not in regular Chat; OpenAI's launch post lists Plus, Pro, Enterprise and Edu, and the Codex docs add Business. Sonnet 5.5 is available in the Claude apps and Claude Code, where it runs at `medium` by default, the setting that scores 8 points below Terra's default on AA. Plan allowances are set per product rather than from API prices: the [ChatGPT Codex pricing page](https://learn.chatgpt.com/docs/pricing), as of October 27, 2026, gives Terra 35–285 local messages per 5-hour window on Plus against 15–160 for GPT-6.1 Sol (compared in [GPT-6.1 Terra vs GPT-6.1 Sol: Half the Price, Not Always Cheaper](https://blog.laozhang.ai/en/posts/gpt-6-1-terra-vs-gpt-6-1-sol)), and Anthropic publishes no message estimate for Sonnet 5.5, so the API cost ratio does not tell you which subscription lasts longer.

## How to test Sonnet 5.5 and Terra on your own prompts

A small same-prompt run of 10–20 real tasks answers the question the benchmarks cannot, which is cost per accepted answer on your work and in your language. The 36 calls in the November 3 test cost about $0.32 at list prices. Do it in this order:

1. Pick 10–20 prompts from real traffic, in the language your users write in, and give each a check you can run without judgment: hidden tests, an exact answer, or a short rubric. Include at least one long prompt if your production prompts run long.
2. Send each prompt to Sonnet 5.5 at the effort you pay for today, set explicitly: `high` if you call the API with defaults, `medium` if you are comparing against Claude Code or the apps. If your production requests send `cache_control`, send it here too.
3. Send the same prompts to Terra at `medium`, then rerun only the failures at `high`. On Chat Completions use `max_completion_tokens`; for `max` effort or tool calling, use the Responses API.
4. Record input, output, reasoning, cache-write and cache-read tokens from each response's usage, and price them with the formula in the bill section above.
5. Rerun any failure once before counting it, then compare cost per accepted answer, not cost per token.

The two request bodies from the test, which you can adapt:

```json
{
  "model": "claude-sonnet-5-5",
  "max_tokens": 32000,
  "thinking": { "type": "adaptive" },
  "output_config": { "effort": "high" },
  "messages": [{ "role": "user", "content": "YOUR PROMPT" }]
}
```

```json
{
  "model": "gpt-6.1-terra",
  "max_completion_tokens": 32000,
  "reasoning_effort": "medium",
  "messages": [{ "role": "user", "content": "YOUR PROMPT" }]
}
```

If Terra passes as many of your checks as Sonnet, the bill ratio from step 4 is your saving, usually 2–3x on short and medium English prompts. If Terra fails tasks that Sonnet passes, check whether they are multi-step agent or office tasks, the kinds where Sonnet leads on AA, and keep those on Sonnet while the rest move.

## Sources

External pages this guide links to, in the order they appear. Last updated 2026-11-03.

- [GPT-6.1 Terra announcement](https://openai.com/index/introducing-gpt-6-1-terra/) (openai.com)
- [Artificial Analysis Sonnet 5.5 vs GPT-6.1 Terra release comparison](https://artificialanalysis.ai/models/releases/comparisons/claude-sonnet-5-5-vs-gpt-6-1-terra) (artificialanalysis.ai)
- [Anthropic's Sonnet 5.5 announcement](https://www.anthropic.com/news/claude-sonnet-5-5) (anthropic.com)
- [Anthropic's Claude pricing page](https://platform.claude.com/docs/en/about-claude/pricing) (platform.claude.com)
- [OpenAI's API pricing page](https://developers.openai.com/api/docs/pricing) (developers.openai.com)
- [Claude prompt caching docs](https://platform.claude.com/docs/en/build-with-claude/prompt-caching) (platform.claude.com)
- [OpenAI model page](https://developers.openai.com/api/docs/models/gpt-5.6-terra) (developers.openai.com)
- [OpenAI deprecations page](https://developers.openai.com/api/docs/deprecations) (developers.openai.com)
- [ChatGPT Codex pricing page](https://learn.chatgpt.com/docs/pricing) (learn.chatgpt.com)