gpt-6-astra

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-astra",
    "messages": [
      { "role": "user", "content": "Review this migration plan and list every step that can fail, with its rollback." }
    ],
    "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-6-astra",
    messages=[{"role": "user", "content": "Review this migration plan and list every step that can fail, with its rollback."}],
    reasoning_effort="high",
    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-astra",
  messages: [{ role: "user", content: "Review this migration plan and list every step that can fail, with its rollback." }],
  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-6-astra",
        "messages": []map[string]string{
            {"role": "user", "content": "Review this migration plan and list every step that can fail, with its rollback."},
        },
        "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) and the effort values are also stated in OpenAI's release notes; the rest was found by testing. The playground on the model page offers only the fields this model accepts.

Request body

model — string, required

Must be gpt-6-astra exactly. OpenAI lists gpt-6-astra as the only snapshot of this model, so there is no dated alias to pin.

messages — array, required

Conversation history, each entry an object with role and content. Roles are system, user and assistant. 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. Omitted, the request runs under the model's ceiling.

reasoning_effort — string

How much the model thinks before answering. See Reasoning effort. OpenAI states no default for GPT-6 Astra; set it explicitly.

stream — boolean, default false

When true, tokens arrive as server-sent events terminated by data: [DONE], with a final chunk carrying usage. Worth enabling on this model: at high effort it 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.

response_format — object, optional

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

Reasoning effort

OpenAI's model page: "reasoning.effort supports low, medium, high, xhigh, and max." Its release notes add that GPT-6 Astra does not support none, and its reasoning guide says defaults are model-dependent without naming one for this model.

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

Tool calling

OpenAI's release notes for GPT-6 Astra: "Tool calling requires the Responses API. If you use tools with Chat Completions, follow the Responses migration guide." Its reasoning guide says the same in one line: "Chat Completions does not support function calling with GPT-6 Astra."

This endpoint therefore does not promise tool calling on GPT-6 Astra: what the model accepts today can change with the vendor's routing, and only the documented surface is guaranteed. Structured outputs (response_format) and streaming are documented for Chat Completions and work here. Route agentic work that depends on a tool loop to a model that documents tools on Chat Completions, such as GPT-5.6 Sol.

Image input

Images go in as image_url content parts and are accepted at their original dimensions. Output is text only.

Pricing dimensions

Billing is per token, from your reAPI credit balance, with separate input and output rates and a second tier for long prompts:

• Reasoning tokens bill as output. Effort is the first lever on cost.
• Prompts over 272K tokens re-price the whole request at the long-context tier — OpenAI's own rule for this model, mirrored here.
• Tier is the second lever. GPT-6 Astra shares its context window, output ceiling and endpoint with the GPT-5.6 family, so moving down a tier changes reasoning depth and price, not capability surface.

Every rate sits below OpenAI's published per-token rate, on both tiers and both dimensions; 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": 1788600000,
  "model": "gpt-6-astra",
  "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.

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:

Tips

• Set the effort on every request. OpenAI names no default for this model; high is the usual starting point for the work it is priced for.
• Stream, and set a generous max_completion_tokens so a deep pass has room to finish.
• 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 — and watch the 272K line, where the long-context tier starts.
• Need a guaranteed tool loop? Use GPT-5.6 Sol on this endpoint, or OpenAI's Responses API directly.

Related

• GPT-6 Astra model page — current rates
• GPT-5.6 Sol — the tier below, with tool calling on this endpoint
• GPT-5.6 Terra — the balanced tier
• GPT-5.6 Luna — the volume tier
• Errors catalog
• Authentication
• Quickstart