GPT-6.1 Sol via API: setup, pricing and caching in Zukko

GPT-6.1 Sol is available in Zukko with the same fetch_... key as the other models — no separate OpenAI account needed. Below: how to connect the GPT-6.1 Sol API from Python and curl, what requests cost, how caching works, and how to tell whether the model fits your tasks.

GPT-6.1 Sol pricing in Zukko

The model ID is gpt-6.1-sol (with a dot). Prices in dollars per 1M tokens as of 6 October 2026:

The intelligence index in the Zukko catalogue is 52. It is the Intelligence Index from Artificial Analysis, a composite score across benchmarks. Models and prices change: current data is at GET https://api.zukko.pro/v1/models or on the Models page in the dashboard.

Connecting the GPT-6.1 Sol API from Python

The official openai package works (pip install openai). Only the address and key change:

from openai import OpenAI

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

resp = client.chat.completions.create(
    model="gpt-6.1-sol",
    messages=[
        {"role": "system", "content": "Answer briefly and to the point."},
        {"role": "user", "content": "Draft a plan to migrate a database from MySQL to PostgreSQL."},
    ],
)
print(resp.choices[0].message.content)
print(resp.usage.prompt_tokens, resp.usage.completion_tokens)

To keep the key out of your code, set OPENAI_BASE_URL=https://api.zukko.pro/v1 and OPENAI_API_KEY=fetch_... and create the client as OpenAI().

Streaming

stream = client.chat.completions.create(
    model="gpt-6.1-sol",
    messages=[{"role": "user", "content": "Explain what idempotency is"}],
    stream=True,
)
for chunk in stream:
    if chunk.choices:
        print(chunk.choices[0].delta.content or "", end="", flush=True)
    elif chunk.usage:
        print(f"\ninput {chunk.usage.prompt_tokens}, output {chunk.usage.completion_tokens}")

The if chunk.choices check is required: at the end of the stream the server sends a separate chunk with usage and an empty choices list.

curl

curl https://api.zukko.pro/v1/chat/completions \
  -H "Authorization: Bearer fetch_your_key" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-6.1-sol",
    "messages": [{"role": "user", "content": "Hi! Answer in one sentence."}]
  }'

The model accepts image input — in the OpenAI format images are passed as part of content with the image_url type (a link or data:image/png;base64,...).

You can also call the model in the Anthropic format via POST /v1/messages — the gateway converts the request. In Codex the model is set in config.toml (model = "gpt-6.1-sol") or at launch: codex -m gpt-6.1-sol; provider setup is described in the Codex guide↗.

Caching: reading cached_tokens

For GPT models caching is visible in both formats. In the OpenAI format the number of tokens read from cache arrives in usage.prompt_tokens_details.cached_tokens. According to OpenAI's documentation, for GPT-5.6 and later models caching turns on automatically when the repeated beginning of a request is at least 1,024 tokens; no special markers are needed.

u = resp.usage
cached = 0
if u.prompt_tokens_details and u.prompt_tokens_details.cached_tokens:
    cached = u.prompt_tokens_details.cached_tokens
print(f"total input {u.prompt_tokens}, from cache {cached}")

For caching to work, keep stable content (system prompt, tool definitions, reference texts) at the start of the request and changing content at the end. Any edit at the start breaks the match.

Cost with and without caching

Formula for GPT: cost = (fresh input × input price + cache read × read price + output × output price) / 1,000,000. There is no cache-write line for GPT.

Example: 1,000 requests, each with 30,000 input tokens, of which 28,000 is an identical beginning and 2,000 is new, with a 1,000-token answer. The first request puts the beginning into cache, the other 999 read it. GPT cache writes are not charged separately: they are not visible in the OpenAI-format response, so the first request is billed entirely at the input price.

• first request: 30,000 × 0.27 / 1,000,000 = $0.0081
• read: 999 × 28,000 = 27,972,000 × 0.013 / 1,000,000 = $0.363636
• fresh input of the rest: 999 × 2,000 = 1,998,000 × 0.27 / 1,000,000 = $0.53946
• output: 1,000 × 1,000 = 1,000,000 × 1.32 / 1,000,000 = $1.32

Total: 0.0081 + 0.363636 + 0.53946 + 1.32 = $2.231196, about $2.23.

Without caching: 30,000,000 × 0.27 / 1,000,000 = $8.1, plus $1.32 of output — $9.42. For comparison, at the vendor's official price without caching: 30 × $2 + 1 × $10 = $70.

The calculation assumes every repeat hit the cache. In practice the share can be lower: the cache lives for a limited time, and per OpenAI's documentation cached_tokens is rounded down to a multiple of 128. Check the real share via cached_tokens on your own requests. The exact cost of a single request is in the X-Zukko-Cost-Micros header on non-streaming responses; totals are in the Usage section of the dashboard.

What to compare GPT-6.1 Sol with

The same workload for all: 1,000 requests of 3,000 input tokens and 1,000 output tokens, no caching. Formula: 3M × input price + 1M × output price.

A dash means the catalogue has no index value. By index, GPT-6.1 Sol sits next to GPT-6 Astra (52 and 53) and costs less. How it differs from GPT-6 Sol in price and caching — in the article GPT-6 Sol or GPT-6.1 Sol↗. Claude Opus 5.5 with an index of 58 is more expensive; it makes sense to keep it for the hardest tasks.

When to choose GPT-6.1 Sol

• You want an intelligence index close to GPT-6 Astra for less. The index gap is one point (52 versus 53); the price gap is in the table.
• Your tool only speaks the OpenAI format and the context is long. For Claude in /v1/chat/completions all input is billed at the input price, while GPT caching is counted in this format too.
• You need image input. GPT-6.1 Sol supports it.

For mass simple tasks (classification, short answers) look at cheaper models — deepseek-v4.1-flash or gemini-3.8-flash. Most importantly, test on your own tasks: take 5–10 real examples with a known correct answer, run them on gpt-6.1-sol and on the model you use now, and compare quality, number of attempts and the total in the Usage section. Request parameters are in the /v1/chat/completions reference↗.

To get started, create a key on the API keys page↗ and put gpt-6.1-sol in the model field.

FAQ

How do I write the model ID correctly?

gpt-6.1-sol — with a dot between 6 and 1. The full list of IDs is returned by GET https://api.zukko.pro/v1/models.

Do I need to enable caching manually?

No, for GPT caching kicks in by itself when the repeated beginning of the request is long enough. Check it via usage.prompt_tokens_details.cached_tokens.

Can I call GPT-6.1 Sol through the Anthropic SDK?

Yes, via POST /v1/messages with the address https://api.zukko.pro (no /v1 — the SDK adds it). GPT cache reads are counted in both formats.

Can I pay from Russia?

Yes: the dollar balance can be topped up via SBP, a Russian bank card or cryptocurrency, from $1.