# Sonnet 5

Move an app from Claude Sonnet 4.6 to Claude Sonnet 5: the model ID changes, three sampling fields go, and reasoning turns on by default.

1. [Change the model ID](#1-change-the-model-id).
2. [Update the request](#2-update-the-request).
3. [Read the answer](#3-read-the-answer).
4. [Set the effort](#4-set-the-effort).
5. [Compare before you switch](#5-compare-before-you-switch).

## 1. Change the model ID

| | From | To |
|---|---|---|
| Model ID | `anthropic/claude-sonnet-4.6` | `anthropic/claude-sonnet-5` |
| Context | 1 000 000 tokens | 1 000 000 tokens |
| Longest answer | 128 000 tokens | 128 000 tokens |
| Reasoning | off unless you ask | on unless you turn it off: `default_enabled` is `true` |
| Effort levels | `low` · `medium` · `high` · `max` | `low` · `medium` · `high` · `xhigh` · `max` |
| `supported_parameters` | holds `temperature`, `top_p`, `top_k` | holds none of the three |

[`GET /v1/model/{lab}/{model}`](/docs/reference/model) answers each model's entry: its context, its longest answer, its fields, its `reasoning`. The request keeps its shape; `model` changes.

```json
{
  "model": "anthropic/claude-sonnet-5",
  "reasoning": {
    "effort": "high"
  },
  "messages": [
    {
      "role": "user",
      "content": "Write the product page for a wool burnous."
    }
  ]
}
```

## 2. Update the request

| You send today | On Sonnet 5 | Send instead |
|---|---|---|
| `temperature`, `top_p` or `top_k` | not taken; Anthropic refuses any value but the default | nothing: steer with the prompt |
| a thinking budget: `reasoning.max_tokens` or `thinking.budget_tokens` | not honoured: reasoning is adaptive only | an effort level |
| no reasoning setting | the model reasons | nothing, or reasoning turned off, as below |

To keep Sonnet 4.6's behaviour, turn reasoning off in the request.

| Route | Reasoning off |
|---|---|
| `/v1/chat/completions` | `reasoning: {"enabled": false}` |
| `/v1/messages` | `thinking: {"type": "disabled"}` |

<div class="dont">
<p>Keep <code>temperature: 0</code> to make answers repeat. Sonnet 5 does not take it.</p>
</div>

<div class="do">
<p>Ask for a fixed shape with <a href="/docs/structured-outputs">Structured outputs</a>, and state in the prompt what must not vary.</p>
</div>

## 3. Read the answer

With reasoning on, every answer carries it, and the reasoning shares the ceiling with the reply.

| Route | Where the reasoning lands | Change |
|---|---|---|
| `/v1/chat/completions` | `choices[0].message.reasoning`, counted in `usage.completion_tokens_details.reasoning_tokens` | raise `max_tokens`: too low a ceiling ends with no text |
| `/v1/messages` | `thinking` blocks, ahead of the `text` block | read blocks by `type`, never `content[0]`; send `thinking` blocks back unchanged with tool results |

Sonnet 5 counts text differently: Anthropic puts the same text at about 30 % more tokens than on Sonnet 4.6. Recount what your prompts hold, and check your `max_tokens`. Both routes: [Chat](/docs/reference/chat-completions) · [Messages](/docs/reference/messages).

## 4. Set the effort

| Route | Field |
|---|---|
| `/v1/chat/completions` | `reasoning.effort`, or `reasoning_effort` |
| `/v1/messages` | `output_config.effort` |

Anthropic gives `high` as the default. `xhigh` is new, between `high` and `max`, for the hardest coding and agent work. Set the level in every request: lower it where answers hold.

## 5. Compare before you switch

Send the same set of real prompts to both IDs, and compare three things.

| Compare | Where |
|---|---|
| the answers | your own check: a test suite, a reviewer, the task's pass rate |
| what each cost | `usage.cost`, in DA, on every answer |
| how much each reasoned | `usage.completion_tokens_details.reasoning_tokens` |

The script sends each prompt three ways and prints one line per run: how the answer ended, what the prompt counted, what the model reasoned, and the charge in DA, then the first words of the answer.

| Run | Model | Reasoning |
|---|---|---|
| `old, off` | `MODEL` | off |
| `new, off` | `CANDIDATE` | off |
| `new, on` | `CANDIDATE` | on, at effort `high` |

```python
import os
from openai import OpenAI

API_KEY = os.environ["OPENDUNES_API_KEY"]
BASE_URL = "https://opendunes.com/v1"
MODEL = "anthropic/claude-sonnet-4.5"
CANDIDATE = "anthropic/claude-sonnet-4.5"
MAX_TOKENS = 4000
PROMPTS = [
    "Write the product page for a wool burnous.",
    "A customer in Oran asks why her parcel is late. Answer her.",
]
OFF = {"reasoning": {"enabled": False}}
ON = {"reasoning": {"enabled": True, "effort": "high"}}
RUNS = [
    ("old, off", MODEL, OFF),
    ("new, off", CANDIDATE, OFF),
    ("new, on", CANDIDATE, ON),
]

client = OpenAI(base_url=BASE_URL, api_key=API_KEY)

for prompt in PROMPTS:
    print(prompt)
    for label, model, fields in RUNS:
        reply = client.chat.completions.create(
            model=model,
            max_tokens=MAX_TOKENS,
            messages=[{"role": "user", "content": prompt}],
            extra_body=fields,
        )
        usage = reply.usage
        details = usage.completion_tokens_details
        thought = details.reasoning_tokens if details else 0
        print(
            f"{label:9} {reply.choices[0].finish_reason:7}",
            f"in {usage.prompt_tokens}",
            f"thought {thought}",
            f"cost {usage.cost}",
        )
        print("   ", (reply.choices[0].message.content or "")[:60])
```

```javascript
import OpenAI from "openai";

const API_KEY = process.env.OPENDUNES_API_KEY;
const BASE_URL = "https://opendunes.com/v1";
const MODEL = "anthropic/claude-sonnet-4.5";
const CANDIDATE = "anthropic/claude-sonnet-4.5";
const MAX_TOKENS = 4000;
const PROMPTS = [
  "Write the product page for a wool burnous.",
  "A customer in Oran asks why her parcel is late. Answer her.",
];
const OFF = { reasoning: { enabled: false } };
const ON = { reasoning: { enabled: true, effort: "high" } };
const RUNS = [
  ["old, off", MODEL, OFF],
  ["new, off", CANDIDATE, OFF],
  ["new, on", CANDIDATE, ON],
];

const client = new OpenAI({ baseURL: BASE_URL, apiKey: API_KEY });

for (const prompt of PROMPTS) {
  console.log(prompt);
  for (const [label, model, fields] of RUNS) {
    const reply = await client.chat.completions.create({
      model,
      max_tokens: MAX_TOKENS,
      messages: [{ role: "user", content: prompt }],
      ...fields,
    });
    const { usage, choices } = reply;
    const thought = usage.completion_tokens_details?.reasoning_tokens ?? 0;
    console.log(
      label.padEnd(9),
      choices[0].finish_reason.padEnd(7),
      `in ${usage.prompt_tokens}`,
      `thought ${thought}`,
      `cost ${usage.cost}`,
    );
    console.log("   ", (choices[0].message.content ?? "").slice(0, 60));
  }
}
```

```go
package main

import (
	"context"
	"fmt"
	"os"
	"strconv"

	"github.com/openai/openai-go/v3"
	"github.com/openai/openai-go/v3/option"
)

const (
	baseURL   = "https://opendunes.com/v1"
	model     = "anthropic/claude-sonnet-4.5"
	candidate = "anthropic/claude-sonnet-4.5"
	maxTokens = 4000
)

type run struct {
	label  string
	model  string
	fields map[string]any
}

func main() {
	apiKey := os.Getenv("OPENDUNES_API_KEY")

	prompts := []string{
		"Write the product page for a wool burnous.",
		"A customer in Oran asks why her parcel is late. Answer her.",
	}
	off := map[string]any{"reasoning": map[string]any{"enabled": false}}
	on := map[string]any{
		"reasoning": map[string]any{"enabled": true, "effort": "high"},
	}
	runs := []run{
		{"old, off", model, off},
		{"new, off", candidate, off},
		{"new, on", candidate, on},
	}

	client := openai.NewClient(
		option.WithBaseURL(baseURL),
		option.WithAPIKey(apiKey),
	)
	for _, prompt := range prompts {
		fmt.Println(prompt)
		for _, r := range runs {
			params := openai.ChatCompletionNewParams{
				Model:     openai.ChatModel(r.model),
				MaxTokens: openai.Int(maxTokens),
				Messages: []openai.ChatCompletionMessageParamUnion{
					openai.UserMessage(prompt),
				},
			}
			params.SetExtraFields(r.fields)
			reply, err := client.Chat.Completions.New(
				context.TODO(), params)
			if err != nil {
				panic(err)
			}
			choice := reply.Choices[0]
			usage := reply.Usage
			fmt.Printf("%-9s %-7s in %d thought %d cost %v\n",
				r.label, choice.FinishReason, usage.PromptTokens,
				usage.CompletionTokensDetails.ReasoningTokens,
				charge(reply))
			fmt.Printf("    %.60s\n", choice.Message.Content)
		}
	}
}

func charge(reply *openai.ChatCompletion) float64 {
	cost := reply.Usage.JSON.ExtraFields["cost"].Raw()
	value, _ := strconv.ParseFloat(cost, 64)
	return value
}
```

```bash cURL
ADDRESS="https://opendunes.com/v1/chat/completions"
MODEL="anthropic/claude-sonnet-4.5"
CANDIDATE="anthropic/claude-sonnet-4.5"
PROMPT="Write the product page for a wool burnous."
OFF='{"reasoning": {"enabled": false}}'
ON='{"reasoning": {"enabled": true, "effort": "high"}}'

run() {
  jq -n --arg model "$2" --arg prompt "$PROMPT" --argjson fields "$3" \
    '{model: $model, max_tokens: 4000,
      messages: [{role: "user", content: $prompt}]} + $fields' |
    curl -s "$ADDRESS" \
      -H "Authorization: Bearer $OPENDUNES_API_KEY" \
      -H "Content-Type: application/json" \
      -d @- |
    jq -c --arg label "$1" '{label: $label,
      finish: .choices[0].finish_reason,
      in: .usage.prompt_tokens,
      thought: .usage.completion_tokens_details.reasoning_tokens,
      cost: .usage.cost,
      answer: ((.choices[0].message.content // "") | .[:60])}'
}

run "old, off" "$MODEL" "$OFF"
run "new, off" "$CANDIDATE" "$OFF"
run "new, on" "$CANDIDATE" "$ON"
```

The samples put `anthropic/claude-sonnet-4.5` in both seats, so they run as they stand. Set `MODEL` to `anthropic/claude-sonnet-4.6` and `CANDIDATE` to `anthropic/claude-sonnet-5`.

Read the first two lines against each other: the only difference is the model, and `in` is the recount. The third line is what reasoning adds, in `thought` and in the charge.

Switch once the new ID holds; going back is the same one-line change. Run your red-team suite on the new ID too: [Red teaming](/docs/cookbook/red-teaming).
