> Markdown mirror of https://router.one/blog/gpt-6-sol-api-guide for AI assistants and crawlers. Router One is an OpenAI-compatible LLM API gateway.
> Published: 2026-09-23 · Author: Router One Team

# GPT-6 Sol API Guide: Endpoints, 272K Price Tier, First Call

_GPT-6 Sol on Router One: openai/gpt-6-sol, 1.05M context, the whole-request 272K tier, plan coverage, Chat Completions and Responses calls, Codex CLI setup._

GPT-6 Sol is in the Router One catalog as `openai/gpt-6-sol` (observed 2026-09-23): a GPT-6 model with a 1,050,000-token context window, text and image input, and tool calling, served on `POST /v1/chat/completions` and natively on `POST /v1/responses` — the wire format Codex CLI speaks. Point any OpenAI-compatible SDK or client at `https://api.router.one/v1`, send `"model": "openai/gpt-6-sol"` with a Router One key, and the request is routed, metered and logged like every other model; the [model page](https://router.one/models/gpt-6-sol) carries the live rates.

This guide covers what the catalog publishes for the id, how its two price lines work, whether subscription plans cover it, the first request on each endpoint, and what changes when you move traffic over from GPT-6 Astra or GPT-5.6 Sol. Catalog observations are dated; the live catalog is the source of truth for a new request.

## GPT-6 Sol at a glance

| Field | What the catalog lists (2026-09-23) |
| --- | --- |
| Catalog id | `openai/gpt-6-sol` |
| Context window | 1,050,000 tokens |
| Max output | 128,000 tokens |
| Input / output | text and image in, text out |
| Capability flags | chat, streaming, tool calling, vision |
| Price lines | two: a standard line, and a whole-request line for requests strictly above 272,000 input tokens |
| Endpoints | `POST /v1/chat/completions`, and natively `POST /v1/responses` |
| Not served on | `POST /v1/messages` (Claude-family and DeepSeek ids only) |

OpenAI's own [GPT-6 Sol model page](https://developers.openai.com/api/docs/models/gpt-6-sol) adds details the catalog does not carry. It describes the model as "built to power complex coding and agentic workflows", gives an April 20, 2026 knowledge cutoff and a maximum of 922,000 input tokens inside the 1,050,000-token window, and documents `reasoning.effort` values `none`, `low`, `medium` (the default), `high`, `xhigh` and `max`. Those are the vendor's statements; what Router One vouches for is the catalog entry and how the gateway routes and bills it.

## Where it sits in the GPT lineup on Router One

On 2026-09-23 the catalog lists 62 ids. The default-channel GPT chat ids are GPT-6 Astra, GPT-6 Sol, GPT-5.6 Sol, GPT-5.6 Terra and GPT-5.5; `codex-auto-review`, the id Codex CLI sends for its review line, is listed on its own. The five share the 1,050,000-token window and the GPT endpoint family; all but GPT-5.5, which the catalog lists with text-only input, also take image input and carry the same 272,000-token tier threshold. What differs is the rate on each model page and how each model does on your prompts — this post does not rank them.

Three comparison pages render the spec sheets and live rates side by side:

- [GPT-6 Sol vs GPT-6 Astra](https://router.one/models/compare/gpt-6-sol-vs-gpt-6-astra) — the two GPT-6 ids in the catalog.
- [GPT-6 Sol vs GPT-5.6 Sol](https://router.one/models/compare/gpt-6-sol-vs-gpt-5-6-sol) — generation over generation.
- [GPT-6 Sol vs Claude Sonnet 5](https://router.one/models/compare/gpt-6-sol-vs-claude-sonnet-5) — the cross-vendor question.

Two things are not listed on 2026-09-23: GPT-6 Luna, and a channel twin of GPT-6 Sol. The Azure channel carries `azure/gpt-6-astra` but no `azure/gpt-6-sol`; the [channel model ids guide](https://router.one/blog/azure-aws-vertex-channel-model-ids) explains what a channel prefix changes. Ids come and go, so check [the catalog](https://router.one/models) before hard-coding one.

## How the two price lines work

The model page shows two rate lines, and the total input tokens of one request select which one applies. At exactly 272,000 input tokens the standard line still applies. Strictly above it, the long-context line applies to the whole request — output included — not only to the tokens past the threshold. Monthly volume plays no part. OpenAI's model page documents the same 272K threshold and the same full-request rule for its own list prices, and the Router One tier mirrors it.

That line matters more than the headline window suggests. An agent loop resends its instructions, the conversation and every earlier tool result on each step, so input grows with every turn; a long coding session can cross 272,000 input tokens well before it gets anywhere near 1,050,000. To stay under the line, compact or trim history before it gets there, and read `usage` on each response to see where a session stands.

The model page also lists cached-input lines. The [prompt caching guide](https://router.one/llm-prompt-caching) shows how to read cache counts in `usage` so input is not counted twice, the [pricing methodology](https://router.one/pricing-methodology) spells out the tier rule, and the [cost calculator](https://router.one/llm-cost-calculator) applies it per request. Reasoning output is billed at the model's posted output rate, with no separate reasoning line ([pricing facts](https://router.one/facts/pricing.md)).

## Do subscription plans cover GPT-6 Sol?

Not as of the 2026-09-23 plan response: no tier of Pro, Max or Ultra lists `gpt-6-sol`, so GPT-6 Sol calls bill per token to your wallet balance at the posted rates, whether or not you hold a plan. For contrast, GPT-5.5 and GPT-5.6 Sol sit in the Premium models tier of all three plans, and GPT-6 Astra in the Flagship models tier that only Max and Ultra carry. That difference is worth checking before you move plan-covered traffic: switching a Codex session from GPT-5.6 Sol to GPT-6 Sol moves it from plan quota to wallet billing. Plan model lists change, and the [pricing page](https://router.one/pricing) shows the live ones.

## Send the first request

1. **Create a key.** Dashboard → API Keys → New key. Keys look like `sk-rk-...`. For a trial, give the key a `maxSpend` cap so a runaway loop stops at a number you chose ([per-key cost tracking](https://router.one/llm-cost-tracking)).
2. **Set the base URL** to `https://api.router.one/v1` in any OpenAI-compatible SDK or client.
3. **Call either endpoint.**

Chat Completions:

```bash
curl https://api.router.one/v1/chat/completions \
  -H "Authorization: Bearer sk-your-api-key" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "openai/gpt-6-sol",
    "messages": [{"role": "user", "content": "List three risks of a whole-request price tier for an agent loop."}]
  }'
```

Responses, with the reasoning effort set explicitly (`medium` is the vendor default):

```bash
curl https://api.router.one/v1/responses \
  -H "Authorization: Bearer sk-your-api-key" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "openai/gpt-6-sol",
    "reasoning": {"effort": "medium"},
    "input": "List three risks of a whole-request price tier for an agent loop."
  }'
```

The same call from the OpenAI Python SDK — only `base_url` and the key change:

```python
from openai import OpenAI

client = OpenAI(
    base_url="https://api.router.one/v1",
    api_key="sk-your-api-key",
)

response = client.responses.create(
    model="openai/gpt-6-sol",
    reasoning={"effort": "medium"},
    input="List three risks of a whole-request price tier for an agent loop.",
)
print(response.output_text)
print(response.usage)
```

`stream: true` works on both endpoints ([streaming guide](https://router.one/llm-streaming)), and so does tool calling ([tool calling guide](https://router.one/llm-tool-calling)). Sending the id to `POST /v1/messages` returns HTTP 400 `invalid_request_error` before any model is called, and the message names the paths that serve it. The [OpenAI-compatible API page](https://router.one/openai-compatible-api) covers the request shape in general, and the [API compatibility facts](https://router.one/facts/api-compatibility.md) state the endpoint rule per family.

4. **Read the trace.** Dashboard → Logs shows each call with model, input and output tokens, cost, latency and status. Retryable upstream failures are absorbed by [automatic fallback](https://router.one/llm-fallback) across the candidate routes for the same model ([per-request observability](https://router.one/llm-observability)).

## Codex CLI in one line

If Codex CLI already talks to Router One, the switch is `model = "gpt-6-sol"` in `~/.codex/config.toml` — the bare name, which the gateway resolves to `openai/gpt-6-sol` — with `wire_api = "responses"` on the provider as before. For a fresh setup, the [Codex CLI in China page](https://router.one/codex-china) has the full config, the [Codex and Responses API page](https://router.one/codex-responses-api) explains why relays without the Responses wire format return 404, and [GPT-6 Sol in Codex CLI, Cursor, Cline and OpenCode](https://router.one/blog/gpt-6-sol-coding-tools-setup) walks through the coding clients one by one.

## Moving traffic from GPT-6 Astra or GPT-5.6 Sol

On the wire, the move is a `model` string change: the same key, base URL, endpoints, 1,050,000-token window and 272,000-token threshold. What does change:

- **Rates.** Each id has its own lines on its model page; the comparison pages above put them side by side on the live catalog.
- **Plan coverage.** GPT-6 Astra (Max and Ultra) and GPT-5.6 Sol (all three plans) are plan-covered as of 2026-09-23; GPT-6 Sol is not.
- **Behavior on your prompts.** A new model answers differently. Run your own prompt set before switching a production path, not a benchmark someone else chose.

A low-risk way to do it: create a second key with a `maxSpend` cap, send a slice of real traffic to `openai/gpt-6-sol` through it, and filter Dashboard → Logs by model to compare cost, latency and status per task against the id you use today. Fallback keeps retrying within the same model's candidate routes; it never swaps GPT-6 Sol for a different model, so the comparison stays clean.

## From mainland China

Requests reach `api.router.one` from mainland China without a VPN, on the same key and base URL. Top up with a card or Alipay through one hosted checkout, or with USDT/USDC on six chains (Tron, BSC, Ethereum, Polygon, Base, Arbitrum). No US credit card required. Pricing starts as low as 10% of official provider list prices (up to 90% off) on select models; the [GPT API page](https://router.one/cheap-gpt-api) and each model page show the rate for a given id.

## FAQ

**What is the model id for GPT-6 Sol on Router One?**
openai/gpt-6-sol. Since 2026-09-23 the bare name gpt-6-sol resolves to the same model, which is convenient in clients such as Codex CLI that take a bare model name. The model page at /models/gpt-6-sol carries the live rates and the endpoint list.

**Can I use GPT-6 Sol in Claude Code?**
No. Claude Code sends Anthropic Messages requests to /v1/messages, and that endpoint serves Claude-family and DeepSeek ids only; a GPT id there returns HTTP 400 invalid_request_error before any model is called. Use GPT-6 Sol from Codex CLI, which speaks the Responses wire format, or from any client that sends Chat Completions to https://api.router.one/v1.

**Does the 272K tier apply only to the tokens above the threshold?**
No. The total input tokens of one request select the line. Exactly at 272,000 the standard line applies; strictly above it, the long-context line applies to the whole request, output included. Monthly usage does not select the tier.

**Is GPT-6 Sol included in Router One subscription plans?**
Not as of the 2026-09-23 plan response: no Pro, Max or Ultra tier lists it, so calls bill per token to wallet balance. GPT-5.5 and GPT-5.6 Sol are in the Premium models tier of all three plans and GPT-6 Astra is in the Flagship models tier of Max and Ultra. The pricing page shows the current plan model lists.

**Is GPT-6 Luna available through Router One?**
Not as of the 2026-09-23 catalog. The live catalog at /models is the only source of truth; this guide makes no promise about future listings.

**Is there an Azure channel version of GPT-6 Sol?**
Not as of 2026-09-23. The Azure channel lists azure/gpt-6-astra but no azure/gpt-6-sol. A channel id is a separately priced product of the same base model, with its own rates and isolated routing; the channel model ids guide has the rules.

**How much does GPT-6 Sol cost through Router One?**
This guide prints no per-token rates because they go stale. The model page shows both lines live, and the comparison pages render the gap against GPT-6 Astra, GPT-5.6 Sol and Claude Sonnet 5. Pricing starts as low as 10% of official provider list prices (up to 90% off) on select models.

## Next steps

- Open the [GPT-6 Sol model page](https://router.one/models/gpt-6-sol) for the live rates, both price lines and the endpoint list.
- Compare it with [GPT-6 Astra](https://router.one/models/compare/gpt-6-sol-vs-gpt-6-astra), [GPT-5.6 Sol](https://router.one/models/compare/gpt-6-sol-vs-gpt-5-6-sol) or [Claude Sonnet 5](https://router.one/models/compare/gpt-6-sol-vs-claude-sonnet-5).
- Wire it into your coding tools with [GPT-6 Sol in Codex CLI, Cursor, Cline and OpenCode](https://router.one/blog/gpt-6-sol-coding-tools-setup).
- Catch up on the rest of this month's catalog changes in the [September 2026 new-model guide](https://router.one/blog/new-llm-models-september-2026).

## See also

- Canonical page: https://router.one/blog/gpt-6-sol-api-guide
- Codex CLI China: https://router.one/codex-china
- All blog posts: https://router.one/blog
- Models and per-model token rates: https://router.one/models (markdown: https://router.one/models.md)
- Pricing: https://router.one/pricing
- API docs (markdown): https://router.one/docs.md
- Company facts: https://router.one/facts/company.md