GPT-5.5 API pricing: what it actually costs per token

Quick answer: GPT-5.5 price per token, official and discounted.

GPT-5.5 is priced at $5.00 per million input tokens and $30.00 per million output tokens on official rate cards. It carries a 1M-token context window, and it is a reasoning model, meaning it can generate internal thinking tokens before it writes the answer you actually read. Those thinking tokens are billed at the output rate, so a call that reasons a lot can cost noticeably more than its visible reply would suggest. The same model id is carried in a discounted catalog at $4.00 input and $24.00 output per million tokens, a flat 20% under official list on both sides. Nothing about the request format changes: same messages array, same reasoning controls, same response shape. Only the base URL and the unit price change. The rest of this page works through where the tokens actually go, a worked monthly cost table, how GPT-5.5 sits next to its siblings, and the practical levers for keeping a bill in check.

Where a GPT-5.5 bill actually comes from.

The lever that actually controls the reasoning-token line item is the effort setting on the request, typically exposed as something like a "low / medium / high" reasoning parameter. Low keeps internal thinking short and is enough for summarization, extraction, and ordinary chat replies. High lets the model work through more steps before answering, which is worth it for multi-step math or a gnarly debugging pass, but it is also the setting most likely to turn a small visible reply into a large bill. Some providers additionally discount tokens that repeat an identical prefix across calls, such as a fixed system prompt or a set of few-shot examples. Where that applies it is a bonus on top of the base per-token price above, not a separate rate you should budget around, since exact eligibility and the size of the discount vary by endpoint and can change without much notice.

• Input tokens: your prompt, any system instructions, and anything you paste in, resent in full on every call in a multi-turn conversation.
• Reasoning tokens: the internal steps GPT-5.5 works through before answering. They are invisible by default and billed at the output rate.
• Output tokens: the visible reply. On a straightforward call this is the whole output-side bill; on a reasoning-heavy call it can be the smaller part of it.
• Context carried forward: a 1M-token window is large enough to hold a big document or codebase, and everything left sitting in it gets billed again on every later call in the same thread.

Worked example: a month of GPT-5.5 requests.

Model three workloads instead of guessing at a single number. Each row assumes a fixed number of monthly requests with a typical mix of input, reasoning, and visible-output tokens per request, then prices that mix at both the official rate and the discounted catalog rate. Because input and output are discounted by the same 20% on the catalog side, the savings percentage on the total bill stays flat at 20% regardless of how much of a given workload is reasoning tokens versus a plain visible reply.

Why a GPT-5.5 invoice looks bigger than expected.

None of these are billing mistakes so much as gaps between what the request looks like and what actually gets metered. The fix in every case is the same: check the effort setting, check what is actually sitting in the context window, and check which rate applies to the workload you are actually running.

• The reasoning effort setting left on a high default: a task that only needed a quick answer still generates a large hidden thinking-token line item.
• Confusing the visible reply length with the billed output: a 300-token answer on screen can sit on top of several thousand reasoning tokens billed at the same rate.
• A growing conversation inside a 1M-token window: the window is large enough that teams forget to prune it, so call forty in a long thread bills far more input than call one did.
• Pricing GPT-5.5 like a flat per-message cost: at official rates, one large-document call with high reasoning can cost more than a hundred short, low-reasoning calls combined.
• Mixing up interactive and asynchronous pricing assumptions: async or batch processing is commonly discounted well below the interactive per-token rate, so estimating a batch job at interactive pricing overstates the number either way.

GPT-5.5 vs the rest of the GPT-5 line.

GPT-5.5 shipped between the prior-generation GPT-5.4 and the newer GPT-5.6 family, and the newer family effectively repriced the same two tiers: GPT-5.6 Terra sits at the same $2.50 / $15.00 official rate GPT-5.4 held, and GPT-5.6 Sol sits at the same $5.00 / $30.00 rate GPT-5.5 holds, each with a marginally larger context window. Picking between them mostly comes down to whether the task needs GPT-5.5's reasoning and full 1M window or can run on a lighter, cheaper tier.

Ways to cut a GPT-5.5 bill.

The first three items are configuration you control inside the request itself. The next two are workflow decisions about when a call happens. The last is a billing decision that touches the base URL and the key and nothing else in your code.

• Set the reasoning effort explicitly on every call instead of trusting whatever your SDK defaults to. Low or medium clears most summarization, extraction, and chat replies; save high for multi-step math or debugging where the extra thinking earns its keep.
• Cap the max output tokens on the response so one rare runaway completion cannot turn into an outsized line item.
• Keep a stable prefix, the system prompt, tool schemas, few-shot examples, at the front of every request. Any prefix-caching discount a provider offers only applies to tokens that repeat exactly.
• Move large one-off documents to async or batch processing instead of the interactive endpoint when a same-second reply is not the requirement.
• Prune conversation history before it grows past what the task needs. A 1M-token context window is a ceiling to reach for when a task calls for it, not a default to fill on every thread.
• Route latency-tolerant or high-volume workloads through a discounted OpenAI-compatible endpoint such as APIsRouter, where GPT-5.5 lists 20% below official rates on pay-as-you-go billing with no subscription.

Switch the base URL and verify the key.

Every field in a GPT-5.5 request stays identical when you point at a different OpenAI-compatible endpoint: the model id, the messages array, the reasoning effort parameter, the max token cap. The only change is where the request goes and which key authorizes it, so rollback is commenting out one line. Verify a new endpoint with a short call before pointing a production key at it. For OpenAI-compatible tools, the base URL ends at /v1, as in the snippets below.

from openai import OpenAI

client = OpenAI(
    api_key="sk-...",
    base_url="https://api.apisrouter.com/v1",
)

response = client.chat.completions.create(
    model="gpt-5.5",
    reasoning_effort="medium",
    messages=[
        {"role": "user", "content": "Summarize this document in 3 bullet points."}
    ],
)
print(response.choices[0].message.content)

FAQ