Tokens and the context window

What a request costs

You pay per token, and the price is quoted per million tokens. Input tokens (what you send) and output tokens (what the model writes) have separate prices. To price one call:

cost = tokens ÷ 1,000,000 × price per million

Do this once for input and once for output, then add the two.

In plain words: work out what share of a million tokens you used. Then take that share of the price.

Here's an example with small numbers. Say input costs $4 per million tokens and output costs $20. A call sends 3,000 tokens and gets 800 back.

• Input: 3,000 ÷ 1,000,000 = 0.003, and 0.003 × $4 = $0.012.
• Output: 800 ÷ 1,000,000 = 0.0008, and 0.0008 × $20 = $0.016.
• Total: $0.012 + $0.016 = $0.028, a little under three cents.

The output was far shorter, yet it cost more, because each output token costs five times as much. The worked example below does the same sum in Python, using the real usage numbers from a call.

import requests

INPUT_PRICE = 4.00    # dollars per million input tokens
OUTPUT_PRICE = 20.00  # dollars per million output tokens

response = requests.post(
    "https://api.anthropic.com/v1/messages",
    headers={"x-api-key": "added-by-the-academy-server", "anthropic-version": "2026-10-21"},
    json={
        "model": "claude-opus-5-5",
        "max_tokens": 1000,
        "messages": [{"role": "user", "content": "Suggest three names for a newsletter about trail running."}],
    },
    timeout=60,
)
response.raise_for_status()
usage = response.json()["usage"]

input_cost = usage["input_tokens"] / 1_000_000 * INPUT_PRICE
output_cost = usage["output_tokens"] / 1_000_000 * OUTPUT_PRICE
cost = input_cost + output_cost

print("Input tokens:", usage["input_tokens"])
print("Output tokens:", usage["output_tokens"])
print(f"This call: ${cost:.6f}")
print(f"50,000 calls like it: ${cost * 50_000:.2f}")

The context window

Think of a suitcase with a weight limit. Everything you pack counts, and you need to leave room for what you'll bring home. A model's context window works the same way. It's the most tokens the model can handle in a single request. Everything counts against it:

• the system prompt, the standing instructions you give the model
• every message in messages, including earlier turns of a conversation
• any documents, data or tool descriptions you include
• the reply the model writes, thinking included

Claude Opus 5.5 has a context window of 1 million tokens. One reply can be up to 128,000 tokens long. Some older models offer 200,000. (In the academy, the proxy caps max_tokens at 1,024 to keep costs down.)

The reply has to fit too. So budget each request like this:

input tokens + max_tokens ≤ context window

In plain words: what you send, plus the room you save for the reply, must not be more than the window. The sign ≤ means "less than or equal to".

Here's an example with small numbers. Say a window holds 1,000 tokens. You send 700 tokens and set max_tokens to 400. Then 700 + 400 = 1,100, which is 100 more than the window, so it won't fit. Lower max_tokens to 300 and the total is exactly 1,000, which fits. In Python, the check is one line: input_tokens + max_tokens <= window.

If what you send doesn't fit, the API turns the request down. It replies with a 400 error, the code for "something is wrong with this request". You'll need to send less.

Bigger isn't automatically better

A million tokens is several long novels. That doesn't mean you should fill it:

• Cost: you pay for every input token, on every call.
• Speed: more input takes longer to read before the first word of the reply appears.
• Focus: models handle long inputs well. Still, a key detail buried among thousands of others is easier to miss than the same detail in a short prompt. Send what the task needs.

Conversations make this worse. The API doesn't remember earlier turns. So each new request sends the whole conversation again, every message and every reply. The code below follows five short turns. Each of your messages is 150 tokens, and each reply is 400.

history_tokens = 0
for turn in range(1, 6):
    history_tokens += 150   # your new message
    print(f"Turn {turn}: sending {history_tokens} input tokens")
    history_tokens += 400   # the reply joins the history for next time

The input grows by 550 tokens each turn: 150, 700, 1,250, 1,800, then 2,350. By the fifth short turn, one request sends 2,350 input tokens. You pay for every one of them again. The Conversations and memory lesson covers ways to keep that in check.

Choosing what to send

Sometimes you have more material than room, such as 5,000 reviews or a year of support tickets. Think of packing that suitcase again. Decide what goes in, in this order:

1. Save room for the reply: subtract max_tokens.
2. Subtract the fixed parts: the system prompt and instructions.
3. Fill what's left with the most useful material first. That might be the newest reviews or the most relevant documents. Add each item only if it still fits.

The retrieval lessons later in Phase 1 show how to find the most relevant pieces automatically. The packing itself takes a few lines of code.

import math

def estimate_tokens(text):
    return math.ceil(len(text) / 4)

reviews = [
    "Arrived in two days and fits perfectly.",
    "The zipper broke after one hike. I want a refund and an apology from someone in charge.",
    "Great color.",
    "Runs small, order a size up.",
]

budget = 30
chosen = []
used = 0
for review in reviews:
    cost = estimate_tokens(review)
    if used + cost <= budget:
        chosen.append(review)
        used += cost
    else:
        print(f"Skipped ({cost} tokens): {review}")

print(f"Using {used} of {budget} tokens")
for review in chosen:
    print("-", review)