You are about to ship a feature that calls GPT-5.5 per request. Walk through how you estimate the token cost before launch.

Short answer·Medium·4.0 · 0·~3 min·Asked atOpenAI

Attempt it

Free · 2 AI evals / day

There are five steps to a good per call cost estimate. **Step one is the encoding.** Use `tiktoken.encoding_for_model('gpt-5.5')`. The function resolves the encoding from the model name; for GPT-5.5 it returns `o200k_base`. Hard coding `cl100k_base` is the classic bug because that is the older GPT-4 era encoding and produces wrong counts on newer models. **Step two is assembling the full prompt as it will go on the wire.** This is not just the user message. It includes the system message, any tool schemas (which the API turns into tokens), and the chat template wrappers around each message. Forgetting any of these undercounts. **Step three is counting input tokens.** `len(enc.encode(text))` for plain strings. For tool schemas, JSON serialize the schema first and encode the result. Sum across all parts. **Step four is estimating output tokens.** Use a published median for similar features, or measure on a representative sample of test calls. **Step five is validating.** Send one real request and compare your estimate to `usage.prompt_tokens` in the response. The API tells you exactly how many tokens it counted; if your estimate disagrees by more than 10 percent, something is missing from your assembly. If the model supports prompt caching, the response also reports `usage.prompt_tokens_details.cached_tokens`, which is billed at the discounted rate.

**Step 1: pick the encoding.** `tiktoken.encoding_for_model('gpt-5.5')` returns `o200k_base`. Resolve by model name rather than hard coding the encoding because OpenAI ships new encodings with new model families and the mismatch produces wrong counts. **Step 2: assemble the full prompt as the API will send it.** This is the most error prone step. The system message, the tool schemas, and the user message all contribute input tokens. Tool schemas are JSON serialized by the SDK before being sent to the model, so the cost is proportional to the schema's serialized length. The chat API also adds per message overhead (roughly 3 tokens per message plus role tokens) that the application never sees but still pays for. **Step 3: count.** For text content, `len(enc.encode(content))`. For tool schemas, `len(enc.encode(json.dumps(schema)))`. Sum across all messages, all tool schemas, and the per message overhead. **Step 4: estimate output tokens.** Use a published median from a representative test set rather than a guess. Output cost dominates input cost for chat applications because output is typically 2 to 6 times more expensive per token. **Step 5: validate against a real call.** Send one canonical request and read `usage.prompt_tokens` from the response. The API counted; you estimated; the gap is your assembly error. A gap over 10 percent means you missed content. Read `usage.prompt_tokens_details.cached_tokens` for prompt cached calls and apply the cached input discount in the per call math; for Anthropic that is roughly one tenth of normal input price in 2026.

Quick reference

TL;DR

Resolve encoding via `encoding_for_model('gpt-5.5')` (returns `o200k_base`), encode the full prompt (system + tools + user + per-message overhead), multiply by prices, and validate against `usage.prompt_tokens`.

Memory aid

Easy to grasp

Think of an Uber ride. The fare is per mile, but the meter starts at pickup, not when you sit down at your destination. To estimate the fare you need to know the right rate card (which depends on the city), the actual distance the car will cover (not just the part you remember), and a way to check the estimate against the real receipt. Estimating API cost is the same. You pick the encoding for the specific model (the rate card), tokenize everything the API will send through the model (the full distance), and confirm against the response's usage field (the receipt).

Key concepts

tiktoken Token cost estimation o200k_base encoding

Detailed answer & concept explanation

~6 min read

Everything you need to truly understand this topic: intuition, mechanics, step by step explanation, code, formulas, and worked example. Click to expand.

Everything you need to truly understand this topic: intuition, mechanics, step by step explanation, code, formulas, and worked example.

Quick scan · 2–4 min

Everything important, quickly.

5 min: resolve encoding by model, assemble the full prompt (system + tools + user + overhead), count input tokens, estimate output from a real sample, validate against `usage.prompt_tokens`, and adjust for the cached input discount.

Code example

python

import json
import tiktoken

# Step 1: resolve the encoding by model name
enc = tiktoken.encoding_for_model('gpt-5.5')  # o200k_base

# Step 2-3: assemble and count
system_msg = "You are a helpful assistant."
tool_schema = {"name": "search", "parameters": {"q": "string"}}
user_msg = "Find papers on RoPE scaling."

per_message_overhead = 3  # OpenAI chat completion accounting
input_tokens = (
    len(enc.encode(system_msg)) + per_message_overhead
    + len(enc.encode(json.dumps(tool_schema)))
    + len(enc.encode(user_msg)) + per_message_overhead
)

# Step 4: estimate output (use a measured median)
estimated_output_tokens = 400

# Step 5: cost (per 1k token prices in 2026; replace with current)
INPUT_PRICE = 0.0025
OUTPUT_PRICE = 0.010
estimated_cost = (
    input_tokens / 1000 * INPUT_PRICE
    + estimated_output_tokens / 1000 * OUTPUT_PRICE
)

# Validate: send a real call and compare usage.prompt_tokens to input_tokens

Side-by-side

Model family (2026)	Encoding	How to count input
GPT-5.5	o200k_base	`tiktoken.encoding_for_model('gpt-5.5')` + `.encode()`
GPT-4 era (4o, 4-turbo)	o200k_base / cl100k_base	Resolve via `encoding_for_model` per specific model
Claude Opus 4.7	Anthropic internal	`client.messages.count_tokens(...)`
Gemini 3.1 Pro	Google internal	`model.count_tokens(...)` on the Vertex SDK
Llama 4 / open weight	Model specific	`AutoTokenizer.from_pretrained(...).encode(text)`

Real-world examples

Real products, models, and research that use this idea.

OpenAI GPT-5.5: `tiktoken.encoding_for_model('gpt-5.5')` returns `o200k_base`; every response carries `usage.prompt_tokens` and `usage.completion_tokens`.
Anthropic Claude Opus 4.7: `client.messages.count_tokens(model='claude-opus-4-7', messages=[...])` returns the server side input token count without consuming a generation.
GitHub Copilot Chat surfaces per call token counts in its enterprise telemetry so admins can attribute cost per user.
LangSmith and Phoenix observability platforms record `prompt_tokens` and `completion_tokens` per trace and compute rolling per call cost from the published price table.

Interviewer follow-ups

What an interviewer would ask next. Try answering before peeking at the approach.

QIf your estimate disagrees with `usage.prompt_tokens` by 20 percent, what are the first three things you check?

QHow does the prompt cache discount change the per call math?

Don't say this

Red flags and common mistakes that signal junior thinking. Click to expand.

Most common mistake

Estimating cost from `len(user_message.split())` only. You miss the system message, the tool schemas, the per message overhead, and the chat template wrappers, all of which contribute to the billed input tokens.

60-second cheat sheet

The night-before-the-interview bullets. Scan these on the way to the call.

References

Primary sources. Skim if you want the original framing.