gpt-5.6-sol

Quick example

curl https://reapi.ai/api/v1/chat/completions \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-5.6-sol",
    "messages": [
      { "role": "user", "content": "Review this migration plan and identify the failure modes." }
    ],
    "reasoning_effort": "high",
    "max_completion_tokens": 16000,
    "stream": true
  }'

from openai import OpenAI

client = OpenAI(
    api_key="YOUR_API_KEY",
    base_url="https://reapi.ai/api/v1",
)

stream = client.chat.completions.create(
    model="gpt-5.6-sol",
    messages=[{"role": "user", "content": "Review this migration plan and identify the failure modes."}],
    reasoning_effort="high",
    max_completion_tokens=16000,
    stream=True,
)
for chunk in stream:
    delta = chunk.choices[0].delta.content
    if delta:
        print(delta, end="")

import OpenAI from "openai";

const client = new OpenAI({
  apiKey: "YOUR_API_KEY",
  baseURL: "https://reapi.ai/api/v1",
});

const stream = await client.chat.completions.create({
  model: "gpt-5.6-sol",
  messages: [{ role: "user", content: "Review this migration plan and identify the failure modes." }],
  reasoning_effort: "high",
  max_completion_tokens: 16000,
  stream: true,
});

for await (const chunk of stream) {
  process.stdout.write(chunk.choices[0]?.delta?.content ?? "");
}

package main

import (
    "bytes"
    "encoding/json"
    "fmt"
    "io"
    "net/http"
)

func main() {
    body, _ := json.Marshal(map[string]any{
        "model": "gpt-5.6-sol",
        "messages": []map[string]string{
            {"role": "user", "content": "Review this migration plan and identify the failure modes."},
        },
        "reasoning_effort":       "high",
        "max_completion_tokens":  16000,
    })
    req, _ := http.NewRequest("POST",
        "https://reapi.ai/api/v1/chat/completions", bytes.NewReader(body))
    req.Header.Set("Authorization", "Bearer YOUR_API_KEY")
    req.Header.Set("Content-Type", "application/json")

    resp, _ := http.DefaultClient.Do(req)
    defer resp.Body.Close()
    out, _ := io.ReadAll(resp.Body)
    fmt.Println(string(out))
}

Authentication

Use your reAPI API key — the same key that calls the image, video and audio endpoints — as a bearer token:

Authorization: Bearer YOUR_API_KEY

Create one under API keys in your reAPI dashboard. Chat requests are billed from the same credit balance as every other model on the platform.

Endpoint

POST /api/v1/chat/completions

Base URL https://reapi.ai/api/v1. The wire format is OpenAI-compatible, so the same SDKs work once you swap the base URL, the key and the model string.

Parameter support on this model

Every field in OpenAI's Chat Completions reference (37 request-body fields as of 2026-09-07) was sent to this endpoint one at a time on that date. Fields not listed below behave as documented by OpenAI.

The sampling restrictions (temperature, top_p) are what OpenAI states for its reasoning models; the rest was found by testing. There is no minimal on this family.

Request body

model — string, required

Must be gpt-5.6-sol exactly. The bare gpt-5.6 alias also routes here; sending the suffixed id pins the tier you are paying for.

messages — array, required

Conversation history, each entry an object with role and content. Roles are system, user, assistant and tool. Text and image parts are supported — see Image input.

max_completion_tokens — integer

Upper bound on generated tokens for this response, reasoning tokens included. The documented maximum output is 128,000 tokens.

reasoning_effort — string, default "medium"

How much the model thinks before answering. See Reasoning effort.

stream — boolean, default false

When true, tokens arrive as server-sent events terminated by data: [DONE]. Worth enabling on this tier in particular: at high effort the model can think for a long time before the first visible token, and a non-streamed request with a large budget can reach an HTTP timeout.

tools / tool_choice — optional

Function definitions and the selection strategy. Functions, web search, file search and computer use are all available on this family, and this generation adds programmatic tool calling.

response_format — object, optional

Constrains the answer's shape, including a JSON schema for machine-consumed output.

Reasoning effort

Six rungs, and unlike some families these do not collapse into one another — each is a distinct behaviour. The default is medium: OpenAI's docs state that "if you omit reasoning.effort, GPT-5.6 defaults to medium in both modes."

There is no minimal on this family.

All six rungs reach the model through this endpoint (measured 2026-09-07); minimal is rejected with a 400. The table above is OpenAI's own description of the family; the parameter table earlier on this page is what this endpoint answers.

This is the tier the top of that ladder exists for. Starting at high and evaluating xhigh and max against your own cases is the usual approach; the medium default will under-use what you are paying for.

Image input

This generation accepts images at their original dimensions, with original or auto image detail — no resizing step required before a screenshot or scan goes in. Output is text only.

Pricing dimensions

Billing is per token, from your reAPI credit balance, with separate input and output rates. Three things to keep in mind:

• Reasoning tokens bill as output. The default effort is medium, so a request that omits the field is paying for a reasoning pass.
• Effort is the first lever, and on this family every rung is real — a middle setting buys a middle cost.
• The tier is the second lever. All three GPT-5.6 tiers share this context window, this output ceiling, this effort ladder and this endpoint, so moving between them changes reasoning depth and price, not capability surface.

Both token rates sit below OpenAI's published per-token rate, on input and output alike; the model page reads them live. Current numbers are on the model page — that table is the canonical source, not this page. The platform constants are 1 credit = $0.001 and $1 = 1,000 credits; a request's cost is its input and output tokens at the per-million rates, converted at that ratio.

Response shape

Non-streaming (stream: false)

{
  "id": "chatcmpl-...",
  "object": "chat.completion",
  "created": 1785000000,
  "model": "gpt-5.6-sol",
  "choices": [
    {
      "index": 0,
      "message": { "role": "assistant", "content": "..." },
      "finish_reason": "stop"
    }
  ],
  "usage": {
    "prompt_tokens": 1204,
    "completion_tokens": 860,
    "total_tokens": 2064
  }
}

usage.completion_tokens includes reasoning tokens, so it is the number to reconcile a bill against. On OpenAI's own Responses API the split is reported under output_tokens_details.reasoning_tokens.

Streaming (stream: true)

Server-sent events, each data: line carrying a chat.completion.chunk with the incremental text in choices[0].delta.content, terminated by data: [DONE].

Errors

Failures use reAPI's standard error envelope. See the errors catalog for the full code list. Common cases:

Tips

• Start at high, not the default. The default is medium; if a route is on this tier it is usually because it needs more than that.
• Evaluate max only against xhigh. OpenAI's own framing is to compare the two rather than jump straight to the top.
• Stream, and set a generous max_completion_tokens so a deep pass has room to finish.
• Send the suffixed id in production. gpt-5.6 works, but it follows whatever OpenAI points the alias at later.
• Keep the routine turns on a cheaper tier. Same key, same endpoint, one model string apart — escalation is a field, not an integration.
• Give it the whole system. A 1.05M-token window is only useful if you actually put the repository, the tests and the history in it.

Related

• GPT-5.6 Sol model page — current rates
• GPT-5.6 Terra — the balanced tier below it
• GPT-5.6 Luna — the volume tier
• Errors catalog
• Authentication
• Quickstart