gpt-6.1-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.1-sol",
    "messages": [
      { "role": "user", "content": "Review this Python function and return the bug and the fix: def avg(xs): return sum(xs) / len(xs) if xs else 0 — callers pass generators as well as lists." }
    ],
    "reasoning_effort": "medium",
    "max_completion_tokens": 2000,
    "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.1-sol",
    messages=[{"role": "user", "content": "Review this Python function and return the bug and the fix: def avg(xs): return sum(xs) / len(xs) if xs else 0 — callers pass generators as well as lists."}],
    reasoning_effort="medium",
    max_completion_tokens=2000,
    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.1-sol",
  messages: [{ role: "user", content: "Review this Python function and return the bug and the fix: def avg(xs): return sum(xs) / len(xs) if xs else 0 — callers pass generators as well as lists." }],
  reasoning_effort: "medium",
  max_completion_tokens: 2000,
  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.1-sol",
        "messages": []map[string]string{
            {"role": "user", "content": "Review this Python function and return the bug and the fix: def avg(xs): return sum(xs) / len(xs) if xs else 0 — callers pass generators as well as lists."},
        },
        "reasoning_effort":      "medium",
        "max_completion_tokens": 2000,
    })
    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.

Request body

The table follows OpenAI's Chat Completions reference (37 request-body fields). Default is OpenAI's documented default. Notes say what reAPI does with the field and what sending it produced on 2026-10-28, one field per request unless the row names a combination. Every field is forwarded unchanged unless its row says otherwise; where the model rejected a value, its error message comes back inside reAPI's error envelope. An accepted field (200) is not proof that it changed the answer.

Checked before anything is forwarded or charged:

• the body is a JSON object of at most 33,554,432 bytes (413 above that)
• model is exactly gpt-6.1-sol (surrounding whitespace is ignored)
• messages is a non-empty array, and every entry is an object with a non-empty role
• stream, when present, is a boolean
• max_completion_tokens / max_tokens, when present and not null, is a positive integer no larger than 128,000
• n, when present and not null, is a positive integer

Everything else, including fields not in the table, is passed through for the model to accept or reject.

reasoning_effort — enum, default medium

OpenAI's model page: "reasoning.effort supports low, medium (default), high, xhigh, and max." OpenAI's GPT-6 guide: "GPT-6 Astra and GPT-6.1 Sol do not support the none reasoning effort."

On this endpoint, low, medium, high and xhigh are applied. max currently returns 400 with "Supported values are: 'low', 'medium', 'high', and 'xhigh'" (checked 2026-10-28); the request is forwarded unchanged and nothing is charged. none and minimal return the same error.

Reasoning tokens bill as output. max_completion_tokens caps them together with the visible answer.

Tool calling

OpenAI's model page: "Tool calling requires the Responses API." Its GPT-6 guide: "GPT-6 Astra, GPT-6.1 Sol, and GPT-6.1 Terra support Chat Completions, but tool calling requires Responses."

On this endpoint, requests with tools or functions return 400 at every effort level offered. Structured outputs and streaming are documented for Chat Completions and work here.

Image input

Images go in as image_url content parts with a public HTTP(S) URL. Image tokens count as input. Output is text only.

Troubleshooting

Failures use the standard envelope: error.code, error.message, error.type and error.request_id. See the errors catalog.

Response envelope

Non-streaming (stream: false)

{
  "id": "req_...",
  "object": "chat.completion",
  "created": 1793150000,
  "model": "gpt-6.1-sol",
  "choices": [
    {
      "index": 0,
      "message": { "role": "assistant", "content": "..." },
      "finish_reason": "stop"
    }
  ],
  "usage": {
    "prompt_tokens": 120,
    "completion_tokens": 48,
    "total_tokens": 168,
    "prompt_tokens_details": { "cached_tokens": 0 },
    "completion_tokens_details": { "reasoning_tokens": 0 }
  }
}

id is the reAPI request id (req_…), the same value as error.request_id on a failure — quote it to support. 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.

Pricing

GPT-6.1 Sol bills per token, from your reAPI credit balance:

cost = input × input_rate + cache_read × cache_read_rate
     + cache_write × cache_write_rate + output × output_rate
1 credit = $0.001
$1 = 1,000 credits

1. Cache reads and writes have their own rates

Prompt tokens served from cache (usage.prompt_tokens_details.cached_tokens) bill at the cache-read rate, 5% of the input rate. The first request that writes a prefix to the cache bills those tokens at the cache-write rate. Keep a stable prefix — system message, instructions, reference documents — at the start of the conversation so repeat requests hit the cache.

Checked on 2026-10-28: a 2,683-token prompt sent twice reported cache_write_tokens: 2680 the first time and cached_tokens: 2680 the second; the second request was billed at about 7% of the first.

2. Reasoning tokens are output

usage.completion_tokens includes reasoning tokens. reasoning_effort and max_completion_tokens are the levers on cost.

3. Prompts over 272K input tokens re-price the whole request

OpenAI's rule for this model: "Prompts with more than 272K input tokens are priced at 2x input and cache rates and 1.5x output for the full request." The long-context rates are listed separately on the model page.

reAPI bills GPT-6.1 Sol at OpenAI's standard per-token rate. Current numbers are on the model page — that table is the canonical source, not this page.

Related

• GPT-6.1 Sol model page — current rates and playground
• GPT-6 Astra — OpenAI's most capable GPT-6 model
• GPT-6.1 Terra — the faster, lower-priced GPT-6.1 model
• GPT-6 Sol — the previous Sol
• GPT-6 Luna
• Errors catalog
• Authentication