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 atAirbnb Cresta OpenAI

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.

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

Concept explanation~2 min read

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

Per call cost estimation looks like simple multiplication: tokens times price. The math is trivial; the work is making sure the token count is right. Most pre ship cost estimates miss the mark not because the price was wrong but because the estimator counted only part of what the API actually sends through the model.

This explanation walks the five step workflow, names the specific encoding and counting calls for the 2026 model families you are most likely to hit, and closes on the validation step that catches the regressions a static estimate cannot.

Step 1: resolve the encoding by model name

The encoding is a model property. tiktoken.encoding_for_model('gpt-5.5') returns the o200k_base encoding, which is the encoding the model was trained with and which the API uses to count input tokens for billing. Calling tiktoken.get_encoding('cl100k_base') directly works but is fragile; cl100k is the GPT-4 era encoding and using it on an o200k model produces wrong counts that drift by 5 to 15 percent depending on content mix.

The pattern that holds across model upgrades is to always resolve by model name. When you upgrade from GPT-4o to GPT-5.5, both happen to use o200k_base so the encoding does not change. When you upgrade from a cl100k_base model to an o200k_base model, the encoding changes and resolving by model name catches the change automatically.

For Anthropic models, use client.messages.count_tokens(model=..., messages=...). Anthropic does not expose its tokenizer the way OpenAI does, so the only authoritative count is the server side count returned by this endpoint. For Gemini, use model.count_tokens(...) on the Vertex SDK. For open weight models (Llama 4, Qwen 3, DeepSeek V4), AutoTokenizer.from_pretrained(...) gives you the canonical tokenizer.

Step 2: assemble the full prompt as the API sends it

Step 3 and 4: count input, estimate output

Step 5: validate against a real call and account for the cache

Situations where this technique stops working.

2–4 min · Everything important, quickly.

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

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 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.

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?

First, the encoding (cl100k_base vs o200k_base mismatch). Second, whether tool schemas are being counted (the SDK serializes them, the estimator might not). Third, per message overhead and chat template wrappers, which add a small but real per message cost.

1 more follow-up an interviewer would ask next. Sign in to reveal them.

Red flags & common mistakes

The phrases 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 bullets to scan on the way to the call.

Pick the encoding via tiktoken.encoding_for_model and name the function's return value for GPT-5.5
List the prompt components that contribute to input tokens beyond the user message

Primary sources. Browse if you want the original framing.