gpt-6.1-terra

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-terra",
    "messages": [
      { "role": "user", "content": "Rewrite this release note for a non-technical customer in under 80 words: v4.2 adds SSO via SAML and raises the export limit to 50k rows." }
    ],
    "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-terra",
    messages=[{"role": "user", "content": "Rewrite this release note for a non-technical customer in under 80 words: v4.2 adds SSO via SAML and raises the export limit to 50k rows."}],
    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-terra",
  messages: [{ role: "user", content: "Rewrite this release note for a non-technical customer in under 80 words: v4.2 adds SSO via SAML and raises the export limit to 50k rows." }],
  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-terra",
        "messages": []map[string]string{
            {"role": "user", "content": "Rewrite this release note for a non-technical customer in under 80 words: v4.2 adds SSO via SAML and raises the export limit to 50k rows."},
        },
        "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. On this endpoint is what reAPI does with the field and what sending it produced on 2026-10-27, one field per request. An accepted field (200) is not proof that it changed the answer; where the response showed no effect, the row says so. Every field is forwarded unchanged unless the row says otherwise.

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-terra (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 none, low, medium (default), high, xhigh, and max." OpenAI's guide: "Start with medium and increase it if the improvement in quality is worth the added time and tokens." GPT-6.1 Sol has no none level; GPT-6.1 Terra does.

Effort is applied on this endpoint. On a multi-step arithmetic question, none answered in 19 tokens and got it wrong; xhigh used 80 reasoning tokens and max 199, and both answered correctly.

Reasoning tokens bill as output. Because the output cap is not enforced on this model at the moment, reasoning_effort and the prompt are the levers that bound output length and cost.

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."

This endpoint therefore does not promise tool calling on GPT-6.1 Terra. Requests with tools are forwarded unchanged — on 2026-10-27 they returned tool_calls — but only the documented surface is guaranteed and that behaviour can change without notice. 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. Output is text only. OpenAI suggests the model for matching product photos to catalog entries, interpreting technical drawings and reading application screens.

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": 1793050000,
  "model": "gpt-6.1-terra",
  "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 Terra 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, far below the input rate. Keep a stable prefix — system message, instructions, reference documents — at the start of the conversation so repeat requests hit the cache.

2. Reasoning tokens are output

usage.completion_tokens includes reasoning tokens. reasoning_effort is the first lever 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." On reAPI the 272K line is measured on uncached input tokens: cache reads and cache writes do not count toward it. The long-context rates are listed separately on the model page.

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.

Related

• GPT-6.1 Terra model page — current rates and playground
• GPT-6 Luna — OpenAI's most efficient GPT-6 model
• GPT-6 Sol
• GPT-6 Astra
• GPT-5.6 Terra — the previous Terra
• Errors catalog
• Authentication