Claude API Pricing: Every Model per Million Tokens, Tracked Daily

Claude's API is billed per token: a price per million tokens you send it (input) and a price per million tokens it writes (output). Below are the prices of every Claude model on 27 October 2026, how they compare with other labs' models, and the tracker that checks them again every morning: a Python job and a dashboard Claude built in Fastero from OpenRouter's public list of 463 models. Open the live price tracker: it updates by itself.

The short answer: per million input and output tokens, Claude Haiku 5.5 costs $0.10 and $0.50 (for prompts up to 100,000 tokens; $0.50 and $2.50 above that), Claude Sonnet 5.5 $2 and $10, Claude Opus 5.5 $4 and $20, and Claude Fable 5.1 $10 and $50. Sending requests through the Batch API halves those prices, and input read from the prompt cache costs a small fraction of fresh input. The newest models are the cheapest of their lines: Opus 5.5 costs 20% less than Opus 5, and Haiku 5.5 a tenth of Haiku 4.5 on prompts up to 100,000 tokens.

The price tracker in Fastero. Live data from OpenRouter's model list, 27 October 2026.

Claude API prices (27 October 2026)

Dollars per million tokens. The batch price applies to requests sent through Anthropic's Message Batches API, which returns results within 24 hours.

* Haiku 5.5 costs $0.50 per million input and $2.50 per million output tokens when the prompt is longer than 100,000 tokens. OpenRouter's list shows only the lower rate. We checked the current models' prices against Anthropic's own list, and the rest match.

What the prices mean in practice:

• Input is everything you send, every time: the instructions, the conversation so far, files and tool results. In a long chat or an agent loop, input usually outweighs output.
• Output includes Claude's thinking. Thinking tokens are billed as output, so a model thinking at high effort costs more per answer than the same model answering briefly.
• The prompt cache cuts repeated input. Input Claude reads back from the cache costs a small fraction of fresh input: $0.20 per million instead of $4 on Opus 5.5. Writing to the five-minute cache costs a quarter more than ordinary input.
• Price per token isn't price per task. Models use different numbers of tokens for the same job, so a cheaper model that needs three attempts can cost more than a dearer one that needs one.

If most of your usage is Claude Code, see what it costs per developer and how to track it.

How Claude's prices compare with other labs

Each lab's most expensive text model among those OpenRouter added in the last six months, on 27 October 2026:

The same comparison on the tracker, where it updates every morning.

Further down the range, at $2 and $10, Claude Sonnet 5.5 is listed at the same price as Gemini 4 Argon and OpenAI's GPT-6.1 Sol. The median output price of text models added in the last 90 days, from every lab, is $1.98 per million tokens.

What else the tracker shows

• 376 models from 64 providers, not counting the free and batch variants OpenRouter lists separately. 144 of them take a context of a million tokens or more.
• New models keep coming faster. OpenRouter added 47 of the models it still lists in September 2026, more than in any earlier month, and 28 in the 30 days to 27 October. Anthropic, OpenAI and Google accounted for 12 of September's 47.
• A log of price changes starts on 27 October 2026: each day's prices are kept, so a cut or a rise shows up the morning after it happens.

OpenRouter's list holds today's prices only, so the change log is the part nobody else keeps for you, and the reason to collect the list every day rather than look it up.

How Claude built the tracker

The setup is the one from our GitHub stars and npm downloads tracker: a Postgres database the job can write to, its address saved in Fastero under Settings → Secrets, and the same database connected read-only for the charts. OpenRouter's list needs no API key.

With Fastero connected to Claude, the prompt:

In Fastero, build a tracker of AI model prices. Every morning, a Python job should
read OpenRouter's public model list (https://openrouter.ai/api/v1/models) and save
each model's input and output price per million tokens, context length, output type
and the date OpenRouter added it, one row per model per day, into a table in the
trackers schema of the database in the Secret OSS_DATABASE_URL. Run it once.
 
Then build a dashboard: how many models are listed, how many were added in the last
30 days, models added per month, every Claude model's prices, each lab's priciest
recent model, and a table of price changes. Refresh it when the data changes, and
ask for a public link.

What Claude did, through Fastero's connector:

Before the page went up, the current Claude models' prices were checked against Anthropic's own list. They matched, with one exception the tracker can't see: Haiku 5.5's higher rate for prompts over 100,000 tokens, which OpenRouter's list leaves out. The dashboard's chart says so in its description.

The job, as it runs every morning:

"""AI model price tracker.
 
Every day: OpenRouter's public list of AI models (no key needed), with each model's price
per million input and output tokens and its context length, saved into Postgres (the Secret
OSS_DATABASE_URL), one row per model per day. OpenRouter gives today's prices only, so price
history builds up one run at a time; the date each model was added to OpenRouter comes with
it, so the list of releases goes back years from the first run.
"""
import datetime as dt
import json
import os
import urllib.request
 
import psycopg2
from psycopg2.extras import execute_values
 
TABLE = """
CREATE TABLE IF NOT EXISTS trackers.llm_models_daily (
  day             date NOT NULL,
  model_id        text NOT NULL,
  name            text NOT NULL,
  provider        text NOT NULL,
  added           date,
  context_length  int,
  output          text,
  input_per_m     numeric,
  output_per_m    numeric,
  PRIMARY KEY (day, model_id)
)"""
 
 
def per_million(price):
    # Dollars per token, as text. A router that picks the model per request has no price (-1).
    value = float(price or 0)
    return round(value * 1_000_000, 4) if value >= 0 else None
 
 
def main():
    req = urllib.request.Request(
        "https://openrouter.ai/api/v1/models", headers={"User-Agent": "fastero-llm-price-tracker (+https://fastero.com)"}
    )
    with urllib.request.urlopen(req, timeout=60) as response:
        models = json.load(response)["data"]
    today = dt.date.today()
    rows = [
        (
            today,
            m["id"],
            m["name"].split(": ", 1)[-1],  # "Anthropic: Claude Sonnet 5.5" -> "Claude Sonnet 5.5"
            m["id"].split("/")[0],
            dt.datetime.fromtimestamp(m["created"], dt.timezone.utc).date() if m.get("created") else None,
            m.get("context_length"),
            "+".join(m.get("architecture", {}).get("output_modalities") or []) or None,  # text, image, ...
            per_million(m["pricing"].get("prompt")),
            per_million(m["pricing"].get("completion")),
        )
        for m in models
    ]
    conn = psycopg2.connect(os.environ["OSS_DATABASE_URL"])
    try:
        with conn, conn.cursor() as cur:
            cur.execute(TABLE)
            execute_values(
                cur,
                "INSERT INTO trackers.llm_models_daily VALUES %s ON CONFLICT (day, model_id) DO UPDATE SET "
                "name = EXCLUDED.name, provider = EXCLUDED.provider, added = EXCLUDED.added, "
                "context_length = EXCLUDED.context_length, output = EXCLUDED.output, "
                "input_per_m = EXCLUDED.input_per_m, output_per_m = EXCLUDED.output_per_m",
                rows,
            )
    finally:
        conn.close()
    print(f"Saved {len(rows)} models from {len({r[3] for r in rows})} providers for {today}.")
 
 
if __name__ == "__main__":
    main()

The change log is one query: each model's price beside its price the day before, kept where they differ.

WITH p AS (
  SELECT day, name, provider, input_per_m, output_per_m,
    lag(day) OVER w AS prev_day, lag(input_per_m) OVER w AS prev_in, lag(output_per_m) OVER w AS prev_out
  FROM trackers.llm_models_daily WHERE model_id NOT LIKE '%:%'
  WINDOW w AS (PARTITION BY model_id ORDER BY day)
)
SELECT day AS "Day", provider AS "Provider", name AS "Model", prev_in AS "Input before", input_per_m AS "Input now",
  prev_out AS "Output before", output_per_m AS "Output now"
FROM p
WHERE prev_day IS NOT NULL AND (input_per_m IS DISTINCT FROM prev_in OR output_per_m IS DISTINCT FROM prev_out)
ORDER BY day DESC, provider LIMIT 100

Get an email when a price changes

Ask Claude: "Email me when any Claude model's price changes." It saves a query counting today's changes, and a Fastero alert runs it on a timetable, at most hourly, and emails when the count rises above zero and again when it falls back. The same works for "when a model under $1 per million output tokens with a million-token context appears", or any other question the table can answer.

For an estimate of what a workload will cost, ask with your own numbers: "We send 40 million input and 6 million output tokens a month. What would that cost on each Claude model, and on the three cheapest models with a million-token context?" Claude runs the SQL through Fastero and can draw the answer as a chart in the chat.

FAQ

How much does the Claude API cost?

From $0.10 per million input tokens and $0.50 per million output tokens for Claude Haiku 5.5 to $10 and $50 for Claude Fable 5.1, on 27 October 2026. Claude Sonnet 5.5 costs $2 and $10, and Claude Opus 5.5 $4 and $20. Batch requests cost half.

What is the cheapest Claude model?

Claude Haiku 5.5, at $0.10 per million input and $0.50 per million output tokens for prompts up to 100,000 tokens, and $0.50 and $2.50 above that. Through the Batch API it costs half again.

Is Claude more expensive than GPT or Gemini?

At the top, no different: Claude Fable 5.1 and OpenAI's GPT-6 Astra are both listed at $10 and $50 per million tokens. In the middle, Claude Sonnet 5.5, Gemini 4 Argon and GPT-6.1 Sol all cost $2 and $10. Some models from DeepSeek, Qwen, Meta and others cost less per output token than any Claude model, though price per token is not price per finished task.

How does prompt caching change the price?

Input read back from the cache costs a small fraction of fresh input, $0.20 instead of $4 per million on Claude Opus 5.5, while writing it to the five-minute cache costs a quarter more than ordinary input. A prompt that repeats a long system prompt or document on every call gets much cheaper once it is cached.

How can I track AI model prices automatically?

Collect a price list every day and keep it: OpenRouter's public model list covers 463 models with no key, and saving each day's copy gives you a price history and a change log that the list itself doesn't keep. The job and the dashboard above do that, and Claude built both in one sitting through Fastero's connector.