LLM API pricing comparison:
Claude vs GPT vs Gemini

Prices are in US dollars per million tokens. A token is a piece of a word, and each model family splits text with its own tokenizer, so the same prompt comes to a different number of tokens on Claude, GPT and Gemini. Each call's usage splits into four kinds of token, each billed at its own price:

The charge for one call is:

charge = ( uncached_input × input_price
         + cache_read     × cache_read_price
         + cache_write    × cache_write_price
         + output         × output_price ) ÷ 1,000,000 × multiplier

The multiplier belongs to the channel group that served the call, and every live group bills at list price today. Models & pricing has the full rules. Three things in that formula move comparisons the most:

Each row links to the model's page with its cache-write price and context window. The vendor pages, Claude API, GPT API and Gemini API, cover the API details, and the model marketplace shows live availability. The same list comes from GET https://lovelyrouter.com/v1/models, which needs no key.

Write P_in, P_out, P_read and P_write for a model's input, output, cache-read and cache-write prices from the table. Prices are per million tokens, so a million input tokens cost exactly P_in. Count tokens in millions and multiply.

A support chatbot#

Each reply reads 1,500 tokens (system prompt, retrieved snippets, the question) and writes 400. Ten thousand replies come to 15 million input and 4 million output tokens, so the bill is 15 × P_in + 4 × P_out. With output at five times the input price, those 4 million output tokens cost more than the 15 million input tokens.

An agent turn with a cached history#

The docs' example turn on claude-sonnet-5.5 has 1,200 uncached input tokens, 30,000 read from the cache, 2,000 written to it and 800 output: (1,200 × P_in + 30,000 × P_read + 2,000 × P_write + 800 × P_out) ÷ 1,000,000. On that model a cache read is a twentieth of the input price, so the 30,000 cached tokens cost what 1,500 uncached ones would. Without caching, all 33,200 input tokens are billed at P_in and the turn costs about four times as much. Claude prompt caching shows how to keep hits high.

A reasoning-heavy task#

A code review sends 6,000 input tokens and gets a 700-token answer, but the model reasons for 5,000 tokens first. You pay for 5,700 output tokens: 6,000 × P_in + 5,700 × P_out, per million. Most of that bill is reasoning. Try a lower effort setting on the same model, and check the answers still hold, before you switch models.

Bulk classification#

A million documents of 800 tokens, each labelled with a 20-token answer: 800 million input and 20 million output tokens, or 800 × P_in + 20 × P_out. Here the input price decides the bill. Put shared instructions first so they can be cached (automatically on GPT and Gemini once the prefix is long enough, with cache_control on Claude), and use the smallest model that labels accurately.

Each vendor sells its models in tiers, from a small, cheap model to a large, expensive one. Compare within a tier first:

A practical way to choose:

1. Start in the middle. Build on claude-sonnet-5.5, gpt-6.1-sol or gemini-3.1-pro.
2. Measure on your own prompts. A few hundred real requests with a pass/fail check tell you more than any leaderboard, and one key calls all three vendors.
3. Step down where quality holds. Send easy traffic (classification, extraction, short replies) to the small model of the same family.
4. Step up only where it doesn't. Use the top tier for the hardest requests, not by default.
5. Compare cost per finished task. A cheaper model that needs more turns or retries can cost more per result.

This script reads live prices from GET /v1/models and prints what a month of the chatbot workload would cost on each model, cheapest first. Install requests and run it; no key needed.

import requests

# Tokens per request. Add cache_read / cache_write if your prompts reuse a prefix.
workload = {"input": 1_500, "cache_read": 0, "cache_write": 0, "output": 400}
requests_per_month = 10_000
multiplier = 1.0  # your channel group's multiplier, shown on the model marketplace


def cost_per_request(model):
    p = model["pricing"]
    read = p["input"] if p.get("cache_read") is None else p["cache_read"]
    # Only Claude bills cache writes separately; elsewhere they are ordinary input.
    write = p["cache_write"] if model["owned_by"] == "Anthropic" else p["input"]
    tokens = (workload["input"] * p["input"] + workload["cache_read"] * read
              + workload["cache_write"] * write + workload["output"] * p["output"])
    return tokens / 1_000_000 * multiplier


models = requests.get("https://lovelyrouter.com/v1/models", timeout=30).json()["data"]
text_models = [m for m in models if m["pricing"].get("input") is not None]  # skips image models
rows = sorted((cost_per_request(m) * requests_per_month, m["owned_by"], m["id"]) for m in text_models)
for monthly, vendor, model_id in rows:
    print(f"{vendor:10} {model_id:24} {monthly:12.2f} USD per month")

Change workload to your own token mix, measured from usage on a few real requests, and the ranking changes with it: output-heavy work favors models with a low output price, long-context work a low input or cache-read price.