Token Counting & Usage with OpenAI

1 · Why tokens, not words essential

The model doesn't see words — it sees tokens, and so does your invoice. A token is a chunk of text, roughly ¾ of a word on average; "tokenization" splits text into these sub-word pieces using a fixed vocabulary. Every request is priced by tokens in two buckets — input (what you send) and output (what comes back) — and output almost always costs several times more per token than input. Internalize that and two instincts follow: shorten prompts, and cap output length.

There are two moments you care about token counts. Before the call, you want to estimate — will this prompt fit the context window, roughly what will it cost? That's a local calculation with tiktoken, no network, no key. After the call, you want the truth — exactly what was billed — which the API reports on resp.usage. Estimate up front, reconcile after.

2 · Counting locally with tiktoken essential

tiktoken is OpenAI's tokenizer library. You load the encoding for your model and count — instantly, offline, for free. This is how you check a prompt fits before paying to find out it doesn't.

count.pyimport tiktoken

enc = tiktoken.encoding_for_model("gpt-4o")   # encoding for the model family

def n_tokens(text: str) -> int:
    return len(enc.encode(text))

prompt = "Summarize the quarterly report in three bullets."
print(n_tokens(prompt))                        # e.g. 9
print(enc.encode("unbelievable"))             # one word → several tokens

3 · Reading resp.usage — the billed truth intermediate

Every response reports what it actually cost. These are the numbers to log on every call.

usage.pyfrom openai import OpenAI
client = OpenAI()

resp = client.responses.create(model="gpt-5.5", input="Hello!")
u = resp.usage
print("input:  ", u.input_tokens)
print("output: ", u.output_tokens)
print("total:  ", u.total_tokens)
print("cached: ", u.input_tokens_details.cached_tokens)   # reused prefix

4 · Tokens → dollars intermediate

A tiny pricing function turns counts into money. Keep rates as inputs (they change), and remember output bills higher than input.

price.pydef dollars(usage, in_rate, out_rate):
    # rates are $ per 1M tokens
    return (usage.input_tokens*in_rate + usage.output_tokens*out_rate) / 1_000_000

# works with a tiny stand-in too (offline):
class U: input_tokens, output_tokens = 1200, 350
print(f"${dollars(U, 5.0, 15.0):.4f}")

5 · A per-feature cost ledger professional

"The OpenAI bill went up" is useless; "the summarizer feature's cost tripled on Tuesday" is actionable. The move is to tag every call with a feature label and accumulate usage per label. Then a monthly report tells you which feature spends what — and a sudden jump points at the exact code path.

ledger.pyfrom collections import defaultdict
ledger = defaultdict(lambda: {"in": 0, "out": 0})

def record(feature, usage):
    ledger[feature]["in"]  += usage.input_tokens
    ledger[feature]["out"] += usage.output_tokens

# after each real call: record("summarizer", resp.usage)
# monthly: price each feature's totals and sort — biggest spender first

6 · Tech-lead — budgets & guardrails tech-lead

At the lead level, token discipline becomes policy: every workload declares an expected token profile and a monthly cost estimate at design time (via tiktoken), production logs actual usage per feature, and an alert fires when actual spend diverges from the estimate. Cap max_output_tokens globally so a runaway generation can't produce a surprise bill, and treat a feature's cost-per-request as a reviewable number like latency or error rate.

Knowledge check check yourself