> Markdown mirror of https://router.one/blog/gpt-6-2-sol-api-guide for AI assistants and crawlers. Router One is a unified, OpenAI-compatible LLM API gateway.
> Published: 2026-11-18 · Author: Router One Team

# GPT-6.2 Sol API Guide: Model ID, Codex, Tool Calls

_GPT-6.2 Sol on Router One: model ID, tool calls on the Responses API, plan quota or wallet billing, Codex's default model and what changes from GPT-6.1 Sol._

Router One lists GPT-6.2 Sol, which OpenAI released on November 17, 2026 (OpenAI API changelog, checked 2026-11-18), as `openai/gpt-6.2-sol` as of the 2026-11-18 catalog, and the gateway also accepts OpenAI's own id, `gpt-6.2-sol`. It carries a 1,050,000-token context window (up to 922,000 input tokens and 128,000 output tokens per OpenAI's model page, checked 2026-11-18), with two posted rate lines split at 272,000 input tokens — at or below 272,000 input tokens the standard line applies, and strictly above 272,000 input tokens the long-context line applies to the whole request, output included. The [GPT-6.2 Sol model page](https://router.one/models/gpt-6-2-sol) lists two endpoints for it: `POST /v1/responses` — the wire format Codex CLI speaks — and `POST /v1/chat/completions`. Point any OpenAI-compatible SDK or client at `https://api.router.one/v1`, send `"model": "openai/gpt-6.2-sol"` with a Router One key, and the request is routed, metered and logged like every other model. In the 2026-11-18 plan response, GPT-6.2 Sol is in the Premium models tier of Router One's Pro, Max and Ultra plans: on a plan its calls draw that tier's shared allowance, and calls beyond it, or without a plan, bill per token to your wallet. The model page carries the live dollar rates for both lines.

This guide covers what the catalog lists for the id, how OpenAI positions it against GPT-6.2 Astra, what changes in requests written for GPT-6.1 Sol, how billing and plans apply, which model Codex CLI picks when your config names none, and the first request on each endpoint. Catalog and plan observations are dated; the live catalog is the source of truth for a new request.

## GPT-6.2 Sol at a glance

| Field | What the catalog lists (2026-11-18) |
| --- | --- |
| Catalog id | `openai/gpt-6.2-sol`, listed as of the 2026-11-18 catalog |
| Short id (alias) | `gpt-6.2-sol`, OpenAI's own model id |
| Context window | 1,050,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/responses` and `POST /v1/chat/completions`, as the model page lists them |
| Not on the model page | `POST /v1/messages`, which Router One lists for Claude-family and DeepSeek ids only |
| Channel | default channel only — the 2026-11-18 catalog lists no Azure-channel id for it |
| Plans | the Premium models tier of Pro, Max and Ultra (2026-11-18 plan response); the wallet beyond the allowance and without a plan |

OpenAI's [GPT-6.2 Sol model page](https://developers.openai.com/api/docs/models/gpt-6.2-sol) (checked 2026-11-18) states the vendor's positioning and request rules. It calls GPT-6.2 Sol "Our go-to model for everyday work, from coding to powering agents at scale", lists a maximum of 922,000 input tokens and 128,000 output tokens inside the 1,050,000-token window and a June 1, 2026 knowledge cutoff, and says "The API rejects requests that set reasoning effort to `none`." The same page lists Chat Completions and Responses among its supported endpoints, and OpenAI's November 17 changelog entry (checked 2026-11-18) adds that tool calling requires the Responses API. Those are OpenAI's statements; what Router One vouches for is the catalog entry and how the gateway routes and bills it.

## GPT-6.2 Sol or GPT-6.2 Astra?

OpenAI's [GPT-6.2 guide](https://developers.openai.com/api/docs/guides/latest-model) (checked 2026-11-18) recommends GPT-6.2 Astra "for the most demanding tasks" and GPT-6.2 Sol "for complex work at lower cost". Its November 17 changelog entry points GPT-6.2 Astra at demanding reasoning and coding tasks and GPT-6.2 Sol at everyday coding and agent workflows, and its models catalog (checked 2026-11-18) suggests GPT-6.2 Sol "to balance intelligence and cost". The [GPT-6.2 Astra model page](https://developers.openai.com/api/docs/models/gpt-6.2-astra) (checked 2026-11-18) calls that model "Our most capable model for your hardest projects, from start to finish". Per the two model pages, both take text and image input and return text, share the 1,050,000-token window with up to 922,000 input and 128,000 output tokens, list the same Responses tools and reject a `none` reasoning effort; GPT-6.2 Sol's knowledge cutoff is June 1, 2026 and GPT-6.2 Astra's is May 18, 2026. The guide's migration quickstart gives both models the same parameter rules. These are OpenAI's descriptions of its own lineup, not Router One measurements: run your own prompts on the same inputs before you move a workload.

What Router One adds to the choice:

- **Which plan allowance.** In the 2026-11-18 plan response, GPT-6.2 Sol counts against the Premium models allowance on Pro, Max and Ultra — the tier that also lists GPT-6.1 Sol, GPT-6 Sol and GPT-5.6 Sol — while GPT-6.2 Astra (`openai/gpt-6.2-astra`, listed as of the 2026-11-18 catalog) counts against the Flagship models allowance, which only Max and Ultra carry and which also lists GPT-6 Astra. On Pro, GPT-6.2 Astra calls bill the wallet (2026-11-18 plan response).
- **How a request counts.** The 2026-11-18 catalog gives both ids the same plan-request rule: 1 request per call, or 2 when the call's total input is strictly above 272,000 tokens.
- **Posted rates.** Router One posts its own rates for each id. The [GPT-6.2 Sol](https://router.one/models/gpt-6-2-sol) and [GPT-6.2 Astra](https://router.one/models/gpt-6-2-astra) model pages show the live figures, so re-baseline cost when you switch.
- **Same request path.** Both are GPT-family ids whose model pages list `/v1/responses`, the Codex CLI path, and `/v1/chat/completions`; per OpenAI, tool calls for either go on the Responses API.

## What changes from GPT-6.1 Sol in your requests

The key, base URL, endpoints, 1,050,000-token window and 272,000-token price line stay the same, and OpenAI's model pages list the same maximum input and output, input types, supported endpoints and Responses tools for both models. What changes, per OpenAI's [GPT-6.2 guide](https://developers.openai.com/api/docs/guides/latest-model) (What's new and migration quickstart, checked 2026-11-18) and the GPT-6.2 Sol model page:

- **The model string.** `openai/gpt-6.1-sol` becomes `openai/gpt-6.2-sol`.
- **Reasoning effort.** The GPT-6.2 Sol model page says the API rejects requests that set reasoning effort to `none`. The migration quickstart says to start a new integration at `medium`, and to use `low` where you currently use `none` or `minimal`. Set it with `reasoning.effort` on Responses or `reasoning_effort` on Chat Completions.
- **Prefix edits.** Starting with GPT-6.2, per the same guide, the Responses API drops reasoning items after mid-conversation edits to the conversation history, certain model changes (including downgrades) or a change of end user or organization; without them, answer quality can decline and the model may spend more tokens repeating earlier work. OpenAI's advice is to keep the prefix unchanged when you change settings between responses.
- **Top-level `instructions`.** GPT-6.2 appends top-level `instructions` after `input` on the Responses API. To keep reusable instructions eligible for prompt caching, OpenAI says to put them in a `developer` message as the first item in `input`, and to use top-level `instructions` only for guidance that applies to the current request.
- **Tool calls.** The rule does not change: per the migration quickstart and the November 17 changelog entry, GPT-6.2 Sol supports Chat Completions, but tool calling requires the Responses API — what GPT-6.1 Sol's model page says for that model.
- **Sampling parameters.** On Chat Completions, omit `temperature`, `top_p`, `logprobs` and `top_logprobs`; on Responses, omit `temperature`, `top_p` and `top_logprobs` and take `message.output_text.logprobs` out of `include` (migration quickstart).
- **Knowledge cutoff.** Per the two model pages, June 1, 2026, against GPT-6.1 Sol's April 30, 2026.

GPT-6.1 Sol remains listed: as of the 2026-11-18 catalog Router One lists `openai/gpt-6.1-sol`, and OpenAI's deprecations page (checked 2026-11-18) names no retirement for it. The [GPT-6.1 Sol API guide](https://router.one/blog/gpt-6-1-sol-api-guide) still applies to it.

## How billing works

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 GPT-6.2 Sol model page (checked 2026-11-18) documents the same 272K threshold and the same full-request rule for its own list prices, and Router One's long-context line uses the same threshold.

Reasoning output is billed at the model's posted output rate, with no separate reasoning line ([pricing facts](https://router.one/facts/pricing.md)), so the reasoning effort is a cost lever as much as a quality one. The model page also lists a cached-input line; 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 long-context rule, and the [cost calculator](https://router.one/llm-cost-calculator) applies it per request. Per OpenAI's GPT-6.2 guide, reusable instructions become eligible for prompt caching when they sit in a `developer` message at the start of `input` rather than in top-level `instructions`.

As of the 2026-11-18 catalog, Router One lists openai/gpt-6.2-sol at $0.40 per 1M input tokens and $2.00 per 1M output tokens; the model page shows the live rate. In the same catalog, a GPT-6.2 Sol request strictly above 272,000 input tokens bills at $0.80 per 1M input tokens and $3.00 per 1M output tokens. The [GPT-6.2 Sol model page](https://router.one/models/gpt-6-2-sol) shows both lines live, and the [GPT-6.2 Astra](https://router.one/models/gpt-6-2-astra) and [GPT-6.1 Sol](https://router.one/models/gpt-6-1-sol) model pages show theirs.

## Do subscription plans cover GPT-6.2 Sol?

Yes, as of the 2026-11-18 plan response: GPT-6.2 Sol is in the Premium models tier of Router One's Pro, Max and Ultra plans, together with GPT-6.1 Sol, GPT-6 Sol, GPT-5.6 Sol and the other models that tier lists. The tier's allowance per 30-day cycle (the pricing page lists each plan's allowance) is one pool shared by every model in the tier, not a separate allowance per model. Per the 2026-11-18 catalog, a GPT-6.2 Sol request draws 1 request, or 2 when its total input is strictly above 272,000 tokens; the input count includes cached input once, and output does not count. Calls beyond the cycle's allowance bill the wallet at the posted rates. In the same plan response, GPT-6.2 Astra sits in the Flagship models tier that only Max and Ultra carry, beside GPT-6 Astra. Plan model lists change, and the [pricing page](https://router.one/pricing) shows the live ones.

## Codex CLI: the default model and the one-line switch

Per the openai/codex source (rust-v0.169.1, checked 2026-11-18), Codex 0.169.1, released 2026-11-17, lists `gpt-6.2-sol` first in its bundled model list, so from 0.169.1 a `config.toml` with no top-level `model` line asks for `gpt-6.2-sol`. The rust-v0.169.0 list has no GPT-6.2 entry, and Codex 0.159.1 through 0.169.0 ask for `gpt-6.1-sol` instead (the [GPT-6.1 Sol API guide](https://router.one/blog/gpt-6-1-sol-api-guide) has that history). The Router One one-click install writes `model = "gpt-6.2-sol"` (earlier installs wrote `gpt-5.6-sol`), so a setup it wrote keeps the model it names after a Codex update.

To run GPT-6.2 Sol in Codex, set `model = "gpt-6.2-sol"` as a top-level line above the `[model_providers]` table in `~/.codex/config.toml` — the bare name from Codex's own model list, which the gateway resolves to `openai/gpt-6.2-sol` — and keep `wire_api = "responses"` on the provider. That needs Codex 0.169.1 or later, because earlier versions have no bundled entry for the name, so update with `npm install -g @openai/codex` first. Per the same source, rust-v0.169.1's entry for `gpt-6.2-sol` sets a 500,000-token default context window and `low` as its default reasoning level.

On a Pro, Max or Ultra plan, moving Codex from `gpt-5.6-sol` to `gpt-6.2-sol` keeps it on the same allowance: in the 2026-11-18 plan response `gpt-6.2-sol`, `gpt-6.1-sol` and `gpt-5.6-sol` are all in the Premium models tier of the Pro, Max and Ultra plans, so each request Codex sends to one of them draws from that tier's shared allowance, and calls beyond it bill the wallet at the posted rates. Without a plan, every request Codex sends bills the wallet at GPT-6.2 Sol's posted rates ([model page](https://router.one/models/gpt-6-2-sol)). The [Codex CLI in China page](https://router.one/codex-china) has the full config, and the [Codex and Responses API page](https://router.one/codex-responses-api) explains why relays without the Responses wire format fail with Codex.

## Send the first request

1. **Create a key.** Dashboard → API Keys → Create Key. Keys look like `sk-...`. For a trial, give the key a `maxSpend` cap. A key's spend cap (maxSpend) limits what that key can charge to your wallet: once its cumulative wallet charges reach the cap, its wallet-billed requests return HTTP 402. Requests covered by your plan's quota draw from the account's shared plan quota and do not count toward any key's cap. Your other keys keep working ([per-key cost tracking](https://router.one/llm-cost-tracking)).
2. **Keep a wallet balance or a plan.** On Pro, Max or Ultra, GPT-6.2 Sol calls draw from the Premium models allowance first (2026-11-18 plan response); without a plan, and beyond the allowance, they bill the wallet — top up in Dashboard → Deposit.
3. **Set the base URL** to `https://api.router.one/v1` in any OpenAI-compatible SDK or client.
4. **Call the model.** The examples use the catalog id `openai/gpt-6.2-sol` and set an explicit output cap.

Responses, with the reasoning effort set explicitly (OpenAI suggests `medium` as the starting point for a new integration):

```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.2-sol",
    "reasoning": {"effort": "medium"},
    "max_output_tokens": 25000,
    "input": "List three risks of a whole-request price tier for an agent loop."
  }'
```

Tool calls go on this endpoint. A function tool in the Responses format:

```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.2-sol",
    "reasoning": {"effort": "low"},
    "max_output_tokens": 25000,
    "tools": [{
      "type": "function",
      "name": "get_order_status",
      "description": "Look up the status of an order by its id.",
      "parameters": {
        "type": "object",
        "properties": {"order_id": {"type": "string"}},
        "required": ["order_id"]
      }
    }],
    "input": "Where is order 8812?"
  }'
```

When the output contains a `function_call` item, run the function and send its result back as a `function_call_output` item with the same `call_id`; OpenAI's reasoning guide recommends passing back the reasoning items from that turn as well. Keep the earlier items unchanged when you do: per the GPT-6.2 guide, edits to the conversation prefix drop reasoning items.

Chat Completions, for clients that send it — without tools, as OpenAI's GPT-6.2 guide specifies:

```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.2-sol",
    "max_completion_tokens": 25000,
    "messages": [{"role": "user", "content": "List three risks of a whole-request price tier for an agent loop."}]
  }'
```

The same Responses 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.2-sol",
    reasoning={"effort": "medium"},
    max_output_tokens=25000,
    input="List three risks of a whole-request price tier for an agent loop.",
)
print(response.status, response.output_text)
print(response.usage)
```

Rules that hold on both endpoints:

- **Set an output cap on every request.** Reasoning tokens count toward the output cap; OpenAI suggests reserving at least 25,000 tokens for reasoning and outputs when you start (reasoning guide, checked 2026-11-18). On the Responses API, per the same guide, a response that reaches the cap comes back with `status: "incomplete"`, possibly before any visible text. On Router One's Chat Completions, `max_tokens` and `max_completion_tokens` both set this cap (if both are sent, `max_completion_tokens` wins); on the Responses API it is `max_output_tokens`.
- **Leave out the sampling parameters.** No `temperature`, `top_p`, `top_logprobs` or `logprobs`, as listed above.
- **Stream long work.** `stream: true` returns output as it is generated, on either endpoint ([streaming guide](https://router.one/llm-streaming)).
- **Stay off `/v1/messages`.** The model page does not list it. Per the [API compatibility facts](https://router.one/facts/api-compatibility.md), a chat-model id outside the Claude and DeepSeek families sent there is rejected with HTTP 400 before any model is called, and the message names /v1/chat/completions.

5. **Read the trace.** Dashboard → Logs shows each call with model, input and output tokens, the wallet charge or plan quota it used, latency and status ([per-request observability](https://router.one/llm-observability)). Retryable upstream failures are absorbed by [automatic fallback](https://router.one/llm-fallback) across the candidate routes for the same model; a GPT-6.2 Sol request is never answered by a different model. Rolling 7-day and 30-day error rates per model sit on the [model reliability board](https://router.one/benchmarks/model-reliability).

## Other coding tools

Coding agents send tools on almost every turn, and per OpenAI's GPT-6.2 guide (checked 2026-11-18) GPT-6.2 Sol takes tool calls only on the Responses API, so agent work with it needs a client that sends Responses requests. Before you point a tool at it, check which protocol that tool sends: the tool table in [GPT-6 Sol in Codex CLI, Cursor, Cline and OpenCode](https://router.one/blog/gpt-6-sol-coding-tools-setup) lists the request path per tool. Claude Code cannot call GPT-6.2 Sol: it sends Anthropic Messages requests, and `/v1/messages` serves Claude-family and DeepSeek ids only.

## 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. The [GPT API page](https://router.one/cheap-gpt-api) and each model page show the rate for a given id. For Codex CLI, see [Codex CLI in China](https://router.one/codex-china).

## FAQ

**What is the model id for GPT-6.2 Sol on Router One?**
openai/gpt-6.2-sol. The gateway also accepts OpenAI's own id, gpt-6.2-sol, which is the name to use in Codex CLI. The hyphenated gpt-6-2-sol in the model page address is the page slug, not a model id. In the 2026-11-18 plan response the model is in the Premium models tier of Pro, Max and Ultra, and either id draws from that allowance on a plan.

**Is GPT-6.2 Sol included in Router One subscription plans?**
Yes, in the Premium models tier: in the 2026-11-18 plan response, Pro, Max and Ultra list GPT-6.2 Sol there, beside GPT-6.1 Sol, GPT-6 Sol and GPT-5.6 Sol, so its calls draw from the tier's shared allowance — 2 requests when the input is above 272,000 tokens — and calls beyond it bill the wallet. The pricing page shows the live plan model lists.

**Which plans cover GPT-6.2 Astra?**
Max and Ultra, through the Flagship models tier: in the 2026-11-18 plan response, GPT-6.2 Astra (openai/gpt-6.2-astra) is in that tier beside GPT-6 Astra, and only those two plans carry it. On Pro, GPT-6.2 Astra calls bill per token to the wallet. As of the 2026-11-18 catalog, Router One's price for openai/gpt-6.2-astra is $1.60 per 1M input tokens and $8.00 per 1M output tokens, and the model page shows the live rate. That is its standard line; its long-context line is on the model page.

**Which model does Codex CLI use when config.toml names none?**
Per the openai/codex source (rust-v0.169.1, checked 2026-11-18), Codex 0.169.1, released 2026-11-17, lists gpt-6.2-sol first in its bundled model list, so from 0.169.1 a config with no model line asks for gpt-6.2-sol; Codex 0.159.1 through 0.169.0 ask for gpt-6.1-sol. The Router One one-click install writes model = "gpt-6.2-sol" (earlier installs wrote gpt-5.6-sol and stay on GPT-5.6 Sol until that line changes). To run GPT-6.2 Sol in a hand-written config, set model = "gpt-6.2-sol" with Codex 0.169.1 or later; on a plan, gpt-6.2-sol and gpt-5.6-sol are both in the Premium models tier (2026-11-18 plan response).

**What changes from GPT-6.1 Sol in my requests?**
Per OpenAI's GPT-6.2 guide and model page (checked 2026-11-18): the model string; the reasoning effort, since OpenAI's API rejects none for GPT-6.2 Sol and the guide suggests low where you used none or minimal, and medium for a new integration; prefix edits on the Responses API, which drop reasoning items; and top-level instructions, which GPT-6.2 appends after input, so reusable instructions belong in a developer message at the start of input. Tool calls stay on the Responses API, and temperature, top_p and top_logprobs (plus logprobs on Chat Completions) still have to go. The key, base URL, the 1,050,000-token window and the 272,000-token price line stay the same.

**Can I call tools on Chat Completions with GPT-6.2 Sol?**
Not per OpenAI: its GPT-6.2 guide (checked 2026-11-18) says GPT-6.2 Astra and GPT-6.2 Sol support Chat Completions, "but tool calling requires Responses", and its November 17 changelog entry says the same. Send tool-using requests to /v1/responses and keep Chat Completions for requests without tools.

**Does the 272K price line apply to GPT-6.2 Sol?**
Yes. Its model page shows two rate lines: exactly at 272,000 input tokens the standard line applies; strictly above it, the long-context line applies to the whole request, output included. Monthly usage does not select the line.

**Is GPT-6.1 Sol being retired?**
Not as of 2026-11-18: OpenAI's deprecations page names no retirement for it. Router One lists openai/gpt-6.1-sol as of the 2026-11-18 catalog, and the GPT-6.1 Sol API guide covers it.

**Can Claude Code call GPT-6.2 Sol?**
No. Claude Code sends Anthropic Messages requests to /v1/messages, which serves Claude-family and DeepSeek ids only; per Router One's API compatibility facts, a chat-model id outside those families is rejected there with HTTP 400 before any model is called.

**How much does GPT-6.2 Sol cost through Router One?**
Per token, at the posted rates on the GPT-6.2 Sol model page: two lines, with reasoning billed as output. As of the 2026-11-18 catalog, Router One's price for openai/gpt-6.2-sol is $0.40 per 1M input tokens and $2.00 per 1M output tokens, and the model page shows the live rate. That is the standard line; strictly above 272,000 input tokens the whole request bills on the long-context line. On Pro, Max and Ultra, GPT-6.2 Sol calls inside the Premium models allowance draw plan requests instead (2026-11-18 plan response).

## Next steps

- Open the [GPT-6.2 Sol model page](https://router.one/models/gpt-6-2-sol) for the live rates, both price lines and the endpoint list, and check per-model rolling error rates on the [model reliability board](https://router.one/benchmarks/model-reliability).
- Weighing GPT-6.2 Astra? Its [model page](https://router.one/models/gpt-6-2-astra) shows the live rates; the [GPT-6 Astra API guide](https://router.one/blog/gpt-6-astra-api-guide) covers [GPT-6 Astra](https://router.one/models/gpt-6-astra), the other model in the Flagship models tier of the 2026-11-18 plan response.
- Staying on GPT-6.1 Sol? The [GPT-6.1 Sol API guide](https://router.one/blog/gpt-6-1-sol-api-guide) and its [model page](https://router.one/models/gpt-6-1-sol) cover it.
- Considering GPT-6.1 Terra? The [GPT-6.1 Terra API guide](https://router.one/blog/gpt-6-1-terra-api-guide) covers its model id and what changes from GPT-6.1 Sol.
- Set up Codex CLI with [Codex CLI in China](https://router.one/codex-china) and the [Codex and Responses API page](https://router.one/codex-responses-api).
- Cap and track spend per key with [per-key cost tracking](https://router.one/llm-cost-tracking), and look up gateway errors in the [LLM API error codes reference](https://router.one/llm-api-error-codes).
- Check which models each plan covers on the [pricing page](https://router.one/pricing).

## See also

- Canonical page: https://router.one/blog/gpt-6-2-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
