500xEngineer.

All postsSHORT3 min read

GPT-6.2 Sol: The 272K API Pricing Catch and How to Stay Under

GPT-6.2 Sol's API input price doubles above 272K input tokens for the full request. My advice: count before sending, trim oversized input and count again; use compaction where supported.

Send GPT-6.2 Sol more than 272K input tokens on the API, and your input price doubles for the full request. OpenAI announced Sol on November 17, 2026, for everyday coding and agent work. It's available in Codex and the API. If you're feeding an agent a growing conversation, this pricing line deserves a check before you send.

Video not loading? Watch the Short on YouTube

The rates

OpenAI's Standard API rates per 1M tokens:

Request size Input Cached input Output
Up to 272K input tokens $2 $0.10 $10
More than 272K input tokens $4 $0.20 $15

The whole request reprices. Input and cached input rates double. Output costs 1.5 times the short-context rate. Caching still has a higher rate above the line.

Sol is available in Codex on paid ChatGPT plans. Enterprise and Edu workspaces need an administrator to enable it. Codex subscription usage is measured through plan usage and credits. The rates and surcharge above are API pricing.

The worked example: our math at OpenAI's rates

This is our arithmetic at OpenAI's Standard rates, assuming all input is uncached with no cache writes. Output is billed separately:

Input tokens Calculation Input cost
270K 0.27 × $2 $0.54
280K 0.28 × $4 $1.12

That's about 4% more input tokens for about twice the input cost. The long rate applies across the request. On that long request, output also costs $15 per 1M tokens instead of $10.

How I'd stay under the line

OpenAI documents two useful API features. My advice: count before sending, trim oversized input and count again. Submit only after the recount is within the limit. Use automatic compaction where supported; it does not enforce the pre-send limit.

Count the input first. The input token count endpoint, POST /v1/responses/input_tokens, accepts the same input format as the Responses API and returns the exact count the model will receive. In the SDK, it's client.responses.input_tokens.count.

Configure compaction for a growing conversation. The Responses API uses context_management with compact_threshold. Server-side compaction runs when the rendered token count crosses that threshold. The guide uses 200,000 tokens in its examples. Choosing a threshold below 272K is our advice where compaction is supported. The guide's example is not a guaranteed pricing safeguard: automatic compaction runs during response streaming and does not guarantee that an oversized input stays below long-context pricing.

Here's the count call and the request setting, using the names from the guides:

from openai import OpenAI

client = OpenAI()
request = {"model": "gpt-6.2-sol", "input": "Review this code change."}
def send_with_limit(request, input_limit):
    count = client.responses.input_tokens.count(**request)
    if count.input_tokens > input_limit:
        raise ValueError("Trim input, then count again before submitting.")
    return client.responses.create(**request)

# Choose input_limit to stay within the pricing line.
# If rejected, trim request["input"] and call send_with_limit again.

# Optional setting from the guide, only where supported.
# This does not enforce the pre-send limit.
compaction_settings = {
    "context_management": [
        {"type": "compaction", "compact_threshold": 200_000}
    ]
}

Add the setting to your Responses create request where compaction is supported. The compaction guide's examples use other models and don't list supported models. Our advice: keep the pre-send count check in your workflow: trim oversized input, then count again before submitting. Submit only when the recount is within the limit. Compaction does not replace that check.

Here's how you get paid

My opinion: sell API teams a context audit. Use their own request logs to find calls above 272K input tokens. Our advice: add a pre-send check that counts input, requires trimming oversized requests and counts again before submission. Add compaction where supported, with a threshold below the line as our advice, and explain that it does not enforce the pre-send limit. Then hand over a before-and-after bill report based on their own usage data.

The deliverable is a check they can keep running and a report they can inspect. No income guaranteed.

Daily email

Get each breakdown in your inbox.

One email each evening, right after the Short goes live: the AI tool it covers, the full write-up with sources, and how to get paid for it. Free, and you can unsubscribe anytime.

Read past emails on Substack

Sources

All postsWatch on YouTube