Claude Opus 5.5 and Sonnet 5 via API - Prompt Caching Guide

The Claude Opus 5.5 API costs $5.40 / $27.00 per 1M tokens in Jantaris, and Claude Sonnet 5 costs $3.24 / $16.20 per 1M tokens. You pay per token from a prepaid USD balance, with no subscription and no monthly minimum. Sonnet is enough for most daily work, I use Opus 5.5 for long agent runs and large codebases, and the cheapest Claude Haiku 4.5 ($1.35 / $6.75 per 1M tokens) for short requests at high volume.

This guide is about the API: Claude inside your own apps, scripts and automations. If you want Claude Code in the terminal, I covered it separately in Claude Code cost: pay per token and Claude Code with a custom base URL.

Claude models in the API and their prices

The Jantaris catalog has five Claude models. All of them run on one key, through the Anthropic SDK or the OpenAI SDK.

Claude Opus 5.5: what matters for API users

Anthropic released Opus 5.5 on September 22, 2026 as the first model in the Claude 5.5 family. It has a 1M-token context window, up to 128K output tokens and a June 2026 knowledge cutoff. Anthropic's docs recommend it as the starting point for most workloads and say it performs at the level of Fable 5.1 on most work at a lower price.

One thing that affects cost: on Opus 5.5, adaptive thinking is always on. The model decides how much to think, and thinking tokens are billed as output tokens. A short answer to a hard question can cost more than its length suggests.

Claude Sonnet 5: what matters for API users

Sonnet 5 is the June 2026 Sonnet, with a 1M-token context and up to 128K output tokens. Anthropic places it close to Opus 4.8 at a lower price. Two things to watch when porting older code:

• Sonnet 5 rejects non-default temperature, top_p and top_k values with a 400 error, so remove them,
• Anthropic says its new tokenizer produces about 30% more tokens for the same text than Sonnet 4.6, so compare the cost of whole requests, not only the rate.

On September 28 Anthropic also released Sonnet 5.5 at the same price as Sonnet 5. As of this writing (October 2, 2026) the Jantaris catalog serves Sonnet 5. The live list is in the model catalog and at GET /v1/models?category=chat.

Which Claude model for which job

How I split the work:

• Haiku 4.5: simple customer questions, ticket tagging, pulling data out of emails. Anywhere latency and volume matter more than depth.
• Sonnet 5: the default for code, reports and documentation, agents with a few tools, fixes and tests.
• Opus 5.5: migrations across hundreds of files, reading a whole repository or contract set in one request, agents that run unattended for a long time.
• Fable 5.1: only when Opus 5.5 fails my tests. It is one of the most expensive chat models in the catalog.

A pattern that works well: plan on Opus, execute on a cheaper model. Opus breaks the task into steps, Sonnet or Haiku carries them out. Every model runs on the same key and balance, so you see the full cost of the workflow in one place.

Calling the Claude API from Python and Node

Jantaris serves both formats: Anthropic Messages (/v1/messages) and OpenAI Chat Completions (/v1/chat/completions). If your code uses the Anthropic SDK, change the base URL and key:

pip install anthropic
export JANTARIS_API_KEY=sk-jt-...

import os
from anthropic import Anthropic

client = Anthropic(base_url="https://jantaris.com", api_key=os.environ["JANTARIS_API_KEY"])

msg = client.messages.create(
    model="claude-opus-5.5",
    max_tokens=2048,
    system="Be specific and concise.",
    messages=[{"role": "user", "content": "Plan a Flask to FastAPI migration in 6 steps."}],
)
print(msg.content[-1].text)
print(msg.usage)  # input_tokens, output_tokens, cache_read_input_tokens...

Note the base URL for the Anthropic SDK is https://jantaris.com without /v1, because the SDK adds the path itself. I read content[-1] because with thinking models the first block of the response can be a thinking block, and the text comes last.

Node.js:

import Anthropic from "@anthropic-ai/sdk";

const client = new Anthropic({ baseURL: "https://jantaris.com", apiKey: process.env.JANTARIS_API_KEY });

const msg = await client.messages.create({
  model: "claude-sonnet-5",
  max_tokens: 1024,
  messages: [{ role: "user", content: "Write unit tests for parse_vat_id(value: str)." }],
});
console.log(msg.content.find((b) => b.type === "text")?.text);

You can call the same models through the OpenAI SDK too, with https://jantaris.com/v1 and model="claude-sonnet-5". That helps when one app mixes Claude with GPT and Gemini. Both formats are documented in Anthropic Messages and Chat completions.

Before writing code, you can try a model by hand in Jantaris Studio's chat tab, on the same balance.

How much does a Claude API request cost?

The formula is the same for every model:

cost = (input tokens / 1,000,000) × input rate
     + (output tokens / 1,000,000) × output rate

A worked example to plug rates into: analysing a 30K-token contract with a 3K-token answer (including thinking) costs 0.03 × the input rate + 0.003 × the output rate. On top of that, watch for:

• thinking tokens, billed as output,
• chat history, resent as input with every turn,
• a long system prompt, paid for again on every request.

That last point is where prompt caching comes in.

Claude prompt caching: what it saves

Prompt caching lets you mark a stable prefix of the request (system prompt, instructions, a document, tool definitions) so the model does not process it from scratch every time. Anthropic's price list works like this:

Anthropic also sets a minimum cacheable length that varies by model (512 tokens for Opus 5.5). A shorter block is silently not cached, with no error.

Marking a block for caching with the Anthropic SDK:

policy = open("refund_policy.md", encoding="utf-8").read()  # long, stable text

msg = client.messages.create(
    model="claude-sonnet-5",
    max_tokens=1024,
    system=[
        {"type": "text", "text": "You answer store customers using the policy below."},
        {"type": "text", "text": policy, "cache_control": {"type": "ephemeral"}},
    ],
    messages=[{"role": "user", "content": "How many days do I have to return an item?"}],
)
u = msg.usage
print(u.cache_creation_input_tokens, u.cache_read_input_tokens, u.input_tokens)

The first request writes the policy to the cache (cache_creation_input_tokens), and requests in the next 5 minutes read it (cache_read_input_tokens).

How this works in Jantaris, plainly: the Jantaris price list has two rates, input and output, with no separate cache line. Cache writes are billed at 1.25× the input rate, and cache reads never cost more than regular input. I do not promise Anthropic's cache-read discount, so before you build a budget on caching, measure it: compare usage and your balance (GET /v1/balance) before and after a batch of requests with and without the cache. Caching pays off when you reread the same long prefix many times in a short window. For one-off requests the write alone makes it more expensive.

Paying for the Claude API

Jantaris bills Claude per token from a prepaid balance:

• USD prices, shown before you send a request,
• top-ups from $10 (packs of $10, $25, $50, $100 and $250),
• the balance never expires, and there is no subscription,
• a failed request is not charged,
• prompts and outputs are not used to train models.

To start: sign up, top up, and create a key in the dashboard. Set a monthly limit on the key. When a request would cross it, the API returns 403, so an agent stops at the limit instead of draining the balance. For more on pricing across vendors, see GPT-6 API pricing and Cheapest LLM API in 2026.

FAQ

How much does the Claude Opus 5.5 API cost?

In Jantaris, $5.40 / $27.00 per 1M tokens, paid from a prepaid balance with no subscription. Thinking tokens, which Opus 5.5 always produces, are billed as output.

How much does Claude Sonnet 5 cost through the API?

$3.24 / $16.20 per 1M tokens. It is a good default for code and writing. Sonnet 5 counts the same text as more tokens than Sonnet 4.6, so compare whole-request costs.

Should I use Opus 5.5 or Sonnet 5?

Sonnet 5 for daily work, Opus 5.5 for long agent runs, large codebases and work where a mistake costs more than the price difference. Test both on a few dozen of your own examples.

Does prompt caching work in Jantaris?

Yes. cache_control is passed to the model, and usage shows tokens written to and read from the cache. The price list has no separate cache rate: writes cost 1.25× the input rate, and reads never cost more than regular input. Measure the effect on your own traffic.

Can I use the Anthropic SDK without code changes?

Almost. Set base_url to https://jantaris.com (no /v1), use your sk-jt-... key and a catalog model id such as claude-opus-5.5. Streaming and tools work as in the original API.