gpt-5.6-luna

Quick example

curl https://api.reapi.ai/v1/chat/completions \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-5.6-luna",
    "messages": [
      { "role": "user", "content": "Classify this ticket. Return only the category id." }
    ],
    "reasoning_effort": "none",
    "max_completion_tokens": 4096,
    "stream": true
  }'

from openai import OpenAI

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

stream = client.chat.completions.create(
    model="gpt-5.6-luna",
    messages=[{"role": "user", "content": "Classify this ticket. Return only the category id."}],
    reasoning_effort="none",
    max_completion_tokens=4096,
    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://api.reapi.ai/v1",
});

const stream = await client.chat.completions.create({
  model: "gpt-5.6-luna",
  messages: [{ role: "user", content: "Classify this ticket. Return only the category id." }],
  reasoning_effort: "none",
  max_completion_tokens: 4096,
  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-luna",
        "messages": []map[string]string{
            {"role": "user", "content": "Classify this ticket. Return only the category id."},
        },
        "reasoning_effort":       "none",
        "max_completion_tokens":  4096,
    })
    req, _ := http.NewRequest("POST",
        "https://api.reapi.ai/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

Chat models are served from the api.reapi.ai gateway, which has its own console and its own key. Create the key there, then send it as a bearer token:

Authorization: Bearer YOUR_API_KEY

Endpoint

POST /v1/chat/completions

Base URL https://api.reapi.ai. 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

model — string, required

Must be gpt-5.6-luna exactly. There is no alias for this tier — the bare gpt-5.6 id routes to the frontier model instead.

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]. On a volume route the useful reason to stream is early cancellation: you can abandon a response that has already gone wrong instead of paying for the rest of it.

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.

group — string, default "default"

Token group on the gateway. Leave it at default unless your account has been given another group to route through.

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.

This is the tier the bottom of that ladder exists for. Set effort explicitly — the default is medium, so a request that omits the field is paying for a reasoning pass a classification route probably does not want.

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, in USD, against your api.reapi.ai 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 20% below OpenAI's published per-token rate, on input and output alike. Current numbers are on the model page and api.reapi.ai/pricing — those tables are the canonical source, not this page.

Response shape

Non-streaming (stream: false)

{
  "id": "chatcmpl-...",
  "object": "chat.completion",
  "created": 1785000000,
  "model": "gpt-5.6-luna",
  "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 the gateway's standard envelope. See the errors catalog for the full code list. Common cases:

Tips

• Set effort explicitly. The default is medium; on this tier none or low is usually what you actually mean.
• Cap max_completion_tokens tight. On volume work it is a cost ceiling, not just a length limit.
• Constrain the output with a schema. A machine-parsed route turns a bad answer into a validation error you can see.
• Do not pair none with a long tool loop. OpenAI ties the no-reasoning rung to routes without multi-chained tool calls; raise the effort instead.
• Use it as the first stage. Cheap triage here, escalation to a dearer tier by model string, is the biggest cost lever on a chat workload.
• The window is the frontier tier's. Dropping to this tier does not force you to split long inputs.

Related

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