# GPT-6 Sol GPT-6 Sol is OpenAI's GPT-6 model for complex coding and agentic workflows, between GPT-6 Astra and GPT-6 Luna in capability and price. Send the official OpenAI Responses or Chat Completions request to SeedRouter: change the base URL and the API key, keep the body. ## Model ID | Model ID | Context window | Max output | Reasoning effort | Default effort | | ----------- | ------------------------- | ----------- | ----------------------------------------------- | -------------- | | `gpt-6-sol` | 1.05M tokens (922K input) | 128K tokens | `none`, `low`, `medium`, `high`, `xhigh`, `max` | `medium` | Input: text and images. Output: text. Knowledge cutoff: April 20, 2026. See the [model page](https://seedrouter.ai/models/gpt-6-sol#pricing) for current prices. ## Quick example ```bash curl https://api.seedrouter.ai/v1/responses \ -H "Authorization: Bearer $SEEDROUTER_API_KEY" \ -H "Content-Type: application/json" \ -d '{ "model": "gpt-6-sol", "input": "Summarize the trade-offs of event sourcing in three bullet points." }' ``` ```python import os from openai import OpenAI client = OpenAI( api_key=os.environ["SEEDROUTER_API_KEY"], base_url="https://api.seedrouter.ai/v1", ) response = client.responses.create( model="gpt-6-sol", input="Summarize the trade-offs of event sourcing in three bullet points.", ) print(response.output_text) ``` ```javascript import OpenAI from "openai"; const client = new OpenAI({ apiKey: process.env.SEEDROUTER_API_KEY, baseURL: "https://api.seedrouter.ai/v1", }); const response = await client.responses.create({ model: "gpt-6-sol", input: "Summarize the trade-offs of event sourcing in three bullet points.", }); console.log(response.output_text); ``` ```go package main import ( "bytes" "fmt" "io" "net/http" "os" ) func main() { body := []byte(`{"model": "gpt-6-sol", "input": "Summarize the trade-offs of event sourcing in three bullet points."}`) req, _ := http.NewRequest("POST", "https://api.seedrouter.ai/v1/responses", bytes.NewReader(body)) req.Header.Set("Authorization", "Bearer "+os.Getenv("SEEDROUTER_API_KEY")) req.Header.Set("Content-Type", "application/json") resp, err := http.DefaultClient.Do(req) if err != nil { panic(err) } defer resp.Body.Close() out, _ := io.ReadAll(resp.Body) fmt.Println(string(out)) } ``` ## Endpoints | Format | Method and path | Authentication | | ----------------------- | ---------------------------------------------------- | ----------------------------------------------------------------------------- | | OpenAI Responses | `POST https://api.seedrouter.ai/v1/responses` | `Authorization: Bearer ` | | OpenAI Chat Completions | `POST https://api.seedrouter.ai/v1/chat/completions` | `Authorization: Bearer ` | | Anthropic Messages | `POST https://api.seedrouter.ai/v1/messages` | `x-api-key: ` or `Authorization: Bearer `, plus `anthropic-version` | The OpenAI endpoints forward your request body as sent and return the official response. Keep the API key in server-side code. ## Parameters Responses API fields: | Name | Type | Required | Default | Notes | | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------- | -------- | ------------- | ---------------------------------------------------------------------------------------------- | | `model` | string | Yes | — | `gpt-6-sol`. | | `input` | string or object\[] | Yes | — | A prompt, or input items: messages whose `content` holds `input_text` and `input_image` parts. | | `instructions` | string | No | — | System (developer) instructions. | | `max_output_tokens` | integer | No | Model maximum | 16–128000. Includes reasoning tokens. | | `reasoning.effort` | enum | No | `medium` | `none`, `low`, `medium`, `high`, `xhigh`, `max`. | | `reasoning.summary` | enum | No | — | `auto`, `concise` or `detailed`: return a summary of the reasoning. | | `reasoning.mode` | enum | No | `standard` | `standard` or `pro`. | | `reasoning.context` | enum | No | `auto` | `auto`, `current_turn` or `all_turns`: which earlier reasoning is shown to the model. | | `text.verbosity` | enum | No | `medium` | `low`, `medium` or `high`. | | `text.format` | object | No | — | Structured output, for example `{"type": "json_schema", "name": "...", "schema": {...}}`. | | `temperature` | number | No | — | 0–2. Accepted only with `reasoning.effort` set to `none`. | | `top_p` | number | No | — | 0–1. Accepted only with `reasoning.effort` set to `none`. | | `top_logprobs` | integer | No | — | 0–20. Accepted only with `reasoning.effort` set to `none`. | | `stream` | boolean | No | `false` | Stream the response as server-sent events. | | `tools`, `tool_choice`, `parallel_tool_calls`, `max_tool_calls`, `include`, `metadata`, `store`, `truncation`, `prompt_cache_key`, `prompt_cache_options`, `prompt_cache_retention`, `context_management`, `moderation`, `prompt`, `previous_response_id`, `conversation`, `user` | — | No | — | Forwarded as sent. | Not available: `background`, `service_tier` (including Batch, Flex and fast mode) and `safety_identifier`. ## Reasoning and effort GPT-6 Sol defaults to `medium`. At `none` the model answers without reasoning, and only then are `temperature`, `top_p` and `top_logprobs` accepted. Higher effort usually means more output tokens, a longer wait and a higher cost. Reasoning tokens are billed as output tokens and count toward `max_output_tokens`. ## Image input Images go in a user message's `content` as `input_image` parts with an `image_url`: ```json {"role": "user", "content": [ {"type": "input_image", "image_url": "https://example.com/chart.png"}, {"type": "input_text", "text": "What does this chart show?"} ]} ``` Replace the example URL with a publicly reachable image of your own. ## Billing dimensions See the [current rates on the model page](https://seedrouter.ai/models/gpt-6-sol#pricing). A request is billed by the tokens it uses: * input tokens, * output tokens, including reasoning, * cached input tokens (`usage.input_tokens_details.cached_tokens`), and * cache-write tokens (`usage.input_tokens_details.cache_write_tokens`). When a prompt has more than 272K input tokens, the whole request is billed at the long-context rates. The charge is taken from the `usage` reported with the finished response. A request that fails is not charged. Your account's usage records show the exact charge for every request. ## Output A non-streaming request returns the official response object: ```json { "id": "resp_...", "object": "response", "status": "completed", "model": "gpt-6-sol", "output": [{"type": "message", "role": "assistant", "content": [{"type": "output_text", "text": "..."}]}], "usage": {"input_tokens": 27, "input_tokens_details": {"cached_tokens": 0, "cache_write_tokens": 0}, "output_tokens": 102, "output_tokens_details": {"reasoning_tokens": 0}, "total_tokens": 129} } ``` With `"stream": true` the response is a stream of the official events, including `response.created`, `response.output_text.delta` and `response.completed`; the final `response.completed` event carries the usage. ## Chat Completions Existing Chat Completions code only needs a new base URL and model ID: ```python from openai import OpenAI client = OpenAI(api_key="YOUR_SEEDROUTER_KEY", base_url="https://api.seedrouter.ai/v1") chat = client.chat.completions.create( model="gpt-6-sol", messages=[{"role": "user", "content": "Hello"}], max_completion_tokens=1024, ) print(chat.choices[0].message.content) ``` Set the output limit with `max_completion_tokens` and the effort with `reasoning_effort`. On Chat Completions, GPT-6 Sol supports function calling only with `reasoning_effort` set to `none`; use the Responses API for reasoning with tools. ## Anthropic Messages format Code written for the Anthropic Messages API can call GPT-6 Sol too: send the Messages body to `/v1/messages` with `"model": "gpt-6-sol"`. The request is converted to Chat Completions, so a field with no Chat Completions counterpart has no effect. The response carries the official Messages fields and may include a few extra usage fields; read `usage.input_tokens`, `usage.output_tokens` and the official fields. ## Errors Errors use `{"error": {"code": ..., "message": "..."}}`. The `code` is a code from the [common error catalog](https://seedrouter.ai/docs/api/errors). Failed requests are not charged. ## Tips * Start with the default `medium` effort, use `none` for fast, simple steps and raise the effort only for hard tasks. * Set `max_output_tokens` high enough for the reasoning as well as the answer: it is one budget for both. * Keep long, reused context at the start of the prompt so later requests read it from the cache at the lower rate. ## Related * [GPT-6 Sol playground and pricing](https://seedrouter.ai/models/gpt-6-sol) * [Download OpenAPI](https://seedrouter.ai/docs/gpt-6-sol.openapi.json) * [Copyable Markdown](https://seedrouter.ai/docs/gpt-6-sol.md)