GPT-6.1 Sol or Claude Sonnet 5: price, cache, API format, choice

The question "GPT-6.1 Sol or Claude Sonnet 5" usually comes up when you need a mid-tier working model for a bot, an agent or text processing and don't want to pay for a flagship. Below is a comparison on things you can verify: input, output and cache prices, API format, and the strength index. At the end there is a way to pick a model on your own tasks in one evening.

What we know about the two models

Prices are US dollars per 1M tokens, Zukko price list as of October 6, 2026.

Models and prices change: the current list is at GET https://api.zukko.pro/v1/models or on the "Models" page in your dashboard.

Price: input, output and cache

By cost component:

• Fresh input: Sonnet 5 is cheaper by $0.07 per 1M ($0.2 vs $0.27).
• Output: Sonnet 5 is cheaper by $0.307 per 1M ($1.013 vs $1.32).
• Cache read: Sol is cheaper by $0.012 per 1M ($0.013 vs $0.025).
• Cache write: not charged separately for Sol — the prefix in the first request is billed in full at the input price ($0.27); for Sonnet 5 a write costs $0.25 per 1M.

Which model costs less depends on what your traffic is made of. The formula:

For Sol there is no cache-write line: the prefix being written counts as fresh input.

Example 1: a chatbot, 10,000 requests

Each request has 2,000 input tokens (1,500 of them are the same system prompt) and 400 output tokens. That is 20M input and 4M output in total; volumes below are in millions of tokens, prices per 1M.

Without cache:

• Sol: 20 × $0.27 + 4 × $1.32 = $5.40 + $5.28 = $10.68
• Sonnet 5: 20 × $0.2 + 4 × $1.013 = $4.00 + $4.052 = $8.052

With cache, if the system prompt is read from cache (15M read, 5M fresh input):

• Sol: 5 × $0.27 + 15 × $0.013 + 4 × $1.32 = $1.35 + $0.195 + $5.28 = $6.825
• Sonnet 5: 5 × $0.2 + 15 × $0.025 + 4 × $1.013 = $1.00 + $0.375 + $4.052 = $5.427

The first request with the system prompt (a cache write for Sonnet 5, the full input price for Sol) happens once per cache lifetime and barely moves the total, so it is left out. For short conversations with noticeable output, Sonnet 5 is cheaper: output makes up most of the bill.

Example 2: an agent with a long context

One agent session: 20K fresh input, 5M cache-read tokens, 100K cache write, 50K output. Sol has no separate write, so those 100K count as fresh input: 0.02 + 0.1 = 0.12M.

• Sol: 0.12 × $0.27 + 5 × $0.013 + 0.05 × $1.32 = $0.0324 + $0.065 + $0.066 = $0.1634
• Sonnet 5: 0.02 × $0.2 + 5 × $0.025 + 0.1 × $0.25 + 0.05 × $1.013 = $0.004 + $0.125 + $0.025 + $0.05065 = $0.20465

Here Sol is cheaper by $0.04125: almost all input comes from cache, and Sol's cache read costs about half as much. How to cost such a session step by step is covered in the article on agent cost with caching↗. Caveat: how many tokens actually hit the cache depends on the client and the provider, so using the same profile for both models is a simplification for comparison. Check the real cache share in the API response.

API format and cache

You can call either model in either format: the gateway converts requests. But the format affects caching.

• GPT-6.1 Sol runs in its native OpenAI format (/v1/chat/completions, /v1/responses). For GPT models the cache is visible in both formats: the response has usage.prompt_tokens_details.cached_tokens. The gateway sees only reads: a write is not charged separately.
• Claude Sonnet 5 gets the cache discount only in the Anthropic format (/v1/messages, Anthropic SDK, Claude Code), where the gateway sees how much input came from cache. In the OpenAI format all Claude input is billed at the input price. So the "with cache" figure from example 1 holds for Sonnet 5 only when called through /v1/messages.

For Sonnet 5 in the Anthropic format, caching is marked with the cache_control field (Claude Code and many clients do it for you):

from anthropic import Anthropic

client = Anthropic(base_url="https://api.zukko.pro", api_key="fetch_...")

resp = client.messages.create(
    model="claude-sonnet-5",
    max_tokens=1024,
    system=[{
        "type": "text",
        "text": "Long system prompt: rules, examples, reference data...",
        "cache_control": {"type": "ephemeral"},
    }],
    messages=[{"role": "user", "content": "User question"}],
)
u = resp.usage
print(u.input_tokens, u.cache_read_input_tokens, u.cache_creation_input_tokens, u.output_tokens)

Note: the Anthropic SDK appends /v1 itself, so the base URL goes without it. For the OpenAI SDK the address is https://api.zukko.pro/v1. More on choosing a format in the docs↗.

Strength index

The Zukko catalog shows a "strength index" — the Artificial Analysis Intelligence Index, an aggregate benchmark score. GPT-6.1 Sol scores 52. Claude Sonnet 5 has no value in that table, so the two cannot be compared by index. That does not mean one is stronger: there is simply no data, and you have to decide by testing.

GPT-6.1 Sol or Claude Sonnet 5: choose by testing

Other people's impressions transfer poorly to your tasks. It is more reliable to run both models on your own examples.

1. Collect 30–50 real requests in tasks.txt, one per line: customer messages, code snippets, documents — whatever the model will do in production.
2. Run them through both models with the script below. It shuffles the answers and saves them without model names.
3. Rate the answers blind (two reviewers are better): A better, B better, or equal.
4. Open key.csv, count the wins and compare them with the cost from the same run and with the estimate for your traffic profile.

import csv
import random
from openai import OpenAI

client = OpenAI(base_url="https://api.zukko.pro/v1", api_key="fetch_...")

PRICES = {  # $ per 1M tokens: input, output (Zukko prices as of 2026-10-06)
    "gpt-6.1-sol": (0.27, 1.32),
    "claude-sonnet-5": (0.2, 1.013),
}

tasks = [s.strip() for s in open("tasks.txt", encoding="utf-8") if s.strip()]
blind, key = [], []

The script calls both models in the OpenAI format, so cost is computed without cache, which is correct for single requests. If your task relies on a long repeated context, estimate that part separately with the formula above. A full Python client example is in the Python docs↗.

If you see no quality difference, choose by the cost estimate for your profile: short conversations with noticeable output favour Sonnet 5, long agent sessions with a large cache share favour Sol. If you do see a difference, take the better one and check whether the price gap fits your budget.

You can create a test key in the dashboard↗ and give it a daily dollar limit so the experiment stays within bounds.

FAQ

Which model is cheaper?

It depends on traffic. Sonnet 5 is cheaper on input and output, Sol on cache reads, and Sol has no separate write charge. For the chatbot above, Sonnet 5 came to $8.052 vs $10.68 without cache, while in the agent session with 5M cached tokens Sol was cheaper: $0.1634 vs $0.20465.

Why does Sonnet 5 have no strength index?

The Zukko catalog has no index value for Sonnet 5 — there is no data. We don't substitute estimates from other sources.

Can I call Sonnet 5 through the OpenAI SDK?

Yes, the gateway converts the format. But for Claude the cache discount only applies in the Anthropic format: in the OpenAI format all input is billed at the input price.

Where do I see actual spend?

In the dashboard under "Usage", or through the spending history API — see the docs↗.