gpt-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-6-sol",
    "messages": [
      { "role": "user", "content": "Review this migration plan for risks and propose a test checklist." }
    ],
    "reasoning_effort": "medium",
    "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-6-sol",
    messages=[{"role": "user", "content": "Review this migration plan for risks and propose a test checklist."}],
    reasoning_effort="medium",
    max_completion_tokens=16000,
    stream=True,
)
for chunk in stream:
    delta = chunk.choices[0].delta.content if chunk.choices else None
    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-6-sol",
  messages: [{ role: "user", content: "Review this migration plan for risks and propose a test checklist." }],
  reasoning_effort: "medium",
  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-6-sol",
        "messages": []map[string]string{
            {"role": "user", "content": "Review this migration plan for risks and propose a test checklist."},
        },
        "reasoning_effort":      "medium",
        "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

Measured on this endpoint on 2026-09-24. Fields not listed below behave as documented by OpenAI.

The playground on the model page offers every field above that has a control; stream starts off and the output cap starts blank, matching OpenAI's defaults. Any other Chat Completions field can be added as JSON under "other fields".

Request body

model — string, required

Must be gpt-6-sol exactly. It is a different model from gpt-5.6-sol.

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 at higher effort, where the model can think for a long time before the first visible token.

response_format — object, optional

Constrains the answer's shape, including a JSON schema for machine-consumed output. Structured outputs are supported on GPT-6 Sol.

Reasoning effort

OpenAI's model page: "reasoning.effort supports none, low, medium (default), high, xhigh, and max." On Chat Completions the same values go in the top-level reasoning_effort field. All six are accepted by this endpoint.

Tool calling

OpenAI's model page: "Use the Responses API for built-in tools and function calling. Chat Completions supports function calling only with reasoning_effort set to none."

That restriction describes OpenAI's own Chat Completions endpoint. On this endpoint, requests with tools returned tool_calls at medium effort as well as at none (measured 2026-09-24), so choose the effort the task needs. Your application executes the returned tool_calls and sends each result back as a tool message in the next request.

Image input

Images go in as image_url content parts. Output is text only.

Pricing dimensions

Billing is per token, from your reAPI credit balance:

• Input, output, cache read and cache write each have their own rate.
• Reasoning tokens bill as output. Effort is the first lever on cost.
• Prompts over 272K input tokens re-price the whole request at the long-context rates — OpenAI's own rule for this model, mirrored here.

Every rate sits below OpenAI's published per-token rate. 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.

Response shape

Non-streaming (stream: false)

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

usage.completion_tokens includes reasoning tokens, and usage.prompt_tokens_details.cached_tokens is the part of the prompt billed at the cache-read rate.

Streaming (stream: true)

Server-sent events, each data: line carrying a chat.completion.chunk with the incremental text in choices[0].delta.content. The last chunk before data: [DONE] carries usage; a chunk with an empty choices array is normal and should be skipped.

Errors

Failures use the standard envelope: error.code, error.message and error.request_id. See the errors catalog for the full code list. Common cases:

Related

• GPT-6 Sol model page — current rates and playground
• GPT-6 Astra
• GPT-5.6 Sol
• Errors catalog
• Authentication
• Quickstart